===============================================================================
40012af4 <ramdisk_allocate>:                                                              
  void *area_begin,                                                                       
  uint32_t media_block_size,                                                              
  rtems_blkdev_bnum media_block_count,                                                    
  bool trace                                                                              
)                                                                                         
{                                                                                         
40012af4:   9d e3 bf a0     save  %sp, -96, %sp                                           
  struct ramdisk *rd = calloc(1, sizeof(*rd));                                            
40012af8:   92 10 20 10     mov  0x10, %o1                                                
40012afc:   40 00 00 35     call  40012bd0 <calloc>                                       
40012b00:   90 10 20 01     mov  1, %o0                                                   
                                                                                          
  if (rd == NULL) {                                                                       
40012b04:   ba 92 20 00     orcc  %o0, 0, %i5                                             
40012b08:   02 80 00 0a     be  40012b30 <ramdisk_allocate+0x3c>                          <== NEVER TAKEN
40012b0c:   80 a6 20 00     cmp  %i0, 0                                                   
    return NULL;                                                                          
  }                                                                                       
                                                                                          
  if (area_begin == NULL) {                                                               
40012b10:   02 80 00 0a     be  40012b38 <ramdisk_allocate+0x44>                          
40012b14:   92 10 00 19     mov  %i1, %o1                                                 
  }                                                                                       
  rd->block_size = media_block_size;                                                      
  rd->block_num = media_block_count;                                                      
  rd->area = area_begin;                                                                  
  rd->trace = trace;                                                                      
  rd->initialized = true;                                                                 
40012b18:   82 10 20 01     mov  1, %g1                                                   
  rd->block_size = media_block_size;                                                      
40012b1c:   f2 27 40 00     st  %i1, [ %i5 ]                                              
  rd->block_num = media_block_count;                                                      
40012b20:   f4 27 60 04     st  %i2, [ %i5 + 4 ]                                          
  rd->area = area_begin;                                                                  
40012b24:   f0 27 60 08     st  %i0, [ %i5 + 8 ]                                          
  rd->trace = trace;                                                                      
40012b28:   f6 2f 60 0e     stb  %i3, [ %i5 + 0xe ]                                       
  rd->initialized = true;                                                                 
40012b2c:   c2 2f 60 0c     stb  %g1, [ %i5 + 0xc ]                                       
                                                                                          
  return rd;                                                                              
}                                                                                         
40012b30:   81 c7 e0 08     ret                                                           
40012b34:   91 e8 00 1d     restore  %g0, %i5, %o0                                        
    area_begin = calloc(media_block_count, media_block_size);                             
40012b38:   40 00 00 26     call  40012bd0 <calloc>                                       
40012b3c:   90 10 00 1a     mov  %i2, %o0                                                 
    if (area_begin == NULL) {                                                             
40012b40:   b0 92 20 00     orcc  %o0, 0, %i0                                             
40012b44:   02 80 00 04     be  40012b54 <ramdisk_allocate+0x60>                          <== NEVER TAKEN
40012b48:   82 10 20 01     mov  1, %g1                                                   
    rd->malloced = true;                                                                  
40012b4c:   10 bf ff f4     b  40012b1c <ramdisk_allocate+0x28>                           
40012b50:   c2 2f 60 0d     stb  %g1, [ %i5 + 0xd ]                                       
      free(rd);                                                                           
40012b54:   90 10 00 1d     mov  %i5, %o0                                                 <== NOT EXECUTED
40012b58:   7f ff c1 2a     call  40003000 <free>                                         <== NOT EXECUTED
40012b5c:   ba 10 20 00     clr  %i5                                                      <== NOT EXECUTED
      return NULL;                                                                        
40012b60:   30 bf ff f4     b,a   40012b30 <ramdisk_allocate+0x3c>                        <== NOT EXECUTED
                                                                                          
===============================================================================
40003844 <ramdisk_free>:                                                                  
                                                                                          
  return rd;                                                                              
}                                                                                         
                                                                                          
void ramdisk_free(ramdisk *rd)                                                            
{                                                                                         
40003844:   9d e3 bf a0     save  %sp, -96, %sp                                           
  if (rd != NULL) {                                                                       
40003848:   80 a6 20 00     cmp  %i0, 0                                                   
4000384c:   02 80 00 0c     be  4000387c <ramdisk_free+0x38>                              <== NEVER TAKEN
40003850:   01 00 00 00     nop                                                           
    if (rd->malloced) {                                                                   
40003854:   c2 0e 20 0d     ldub  [ %i0 + 0xd ], %g1                                      
40003858:   80 a0 60 00     cmp  %g1, 0                                                   
4000385c:   12 80 00 04     bne  4000386c <ramdisk_free+0x28>                             
40003860:   01 00 00 00     nop                                                           
      free(rd->area);                                                                     
    }                                                                                     
    free(rd);                                                                             
40003864:   40 00 00 90     call  40003aa4 <free>                                         
40003868:   81 e8 00 00     restore                                                       
      free(rd->area);                                                                     
4000386c:   40 00 00 8e     call  40003aa4 <free>                                         
40003870:   d0 06 20 08     ld  [ %i0 + 8 ], %o0                                          
    free(rd);                                                                             
40003874:   40 00 00 8c     call  40003aa4 <free>                                         
40003878:   81 e8 00 00     restore                                                       
  }                                                                                       
}                                                                                         
4000387c:   81 c7 e0 08     ret                                                           <== NOT EXECUTED
40003880:   81 e8 00 00     restore                                                       <== NOT EXECUTED
                                                                                          
===============================================================================
400035cc <ramdisk_initialize>:                                                            
rtems_device_driver                                                                       
ramdisk_initialize(                                                                       
    rtems_device_major_number major RTEMS_UNUSED,                                         
    rtems_device_minor_number minor RTEMS_UNUSED,                                         
    void *arg RTEMS_UNUSED)                                                               
{                                                                                         
400035cc:   9d e3 bf 88     save  %sp, -120, %sp                                          
     * This is allocating memory for a RAM disk which will persist for                    
     * the life of the system. RTEMS has no "de-initialize" driver call                   
     * so there is no corresponding free(r).  Coverity is correct that                    
     * it is never freed but this is not a problem.                                       
     */                                                                                   
    r = calloc(rtems_ramdisk_configuration_size, sizeof(struct ramdisk));                 
400035d0:   35 10 00 89     sethi  %hi(0x40022400), %i2                                   
400035d4:   f8 06 a3 14     ld  [ %i2 + 0x314 ], %i4    ! 40022714 <rtems_ramdisk_configuration_size>
400035d8:   92 10 20 10     mov  0x10, %o1                                                
400035dc:   40 00 00 c4     call  400038ec <calloc>                                       
400035e0:   90 10 00 1c     mov  %i4, %o0                                                 
    r->trace = false;                                                                     
400035e4:   c0 2a 20 0e     clrb  [ %o0 + 0xe ]                                           
    for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)                      
400035e8:   80 a7 20 00     cmp  %i4, 0                                                   
400035ec:   02 80 00 2e     be  400036a4 <ramdisk_initialize+0xd8>                        <== NEVER TAKEN
400035f0:   ba 10 00 08     mov  %o0, %i5                                                 
    rtems_ramdisk_config *c = rtems_ramdisk_configuration;                                
400035f4:   39 10 00 89     sethi  %hi(0x40022400), %i4                                   
    {                                                                                     
        char name [] = RAMDISK_DEVICE_BASE_NAME "a";                                      
400035f8:   31 0b d9 19     sethi  %hi(0x2f646400), %i0                                   
400035fc:   33 0b dc 99     sethi  %hi(0x2f726400), %i1                                   
        {                                                                                 
            r->malloced = false;                                                          
            r->initialized = true;                                                        
            r->area = c->location;                                                        
        }                                                                                 
        rc = rtems_blkdev_create(name, c->block_size, c->block_num,                       
40003600:   23 10 00 0d     sethi  %hi(0x40003400), %l1                                   
    rtems_ramdisk_config *c = rtems_ramdisk_configuration;                                
40003604:   b8 17 23 18     or  %i4, 0x318, %i4                                           
    for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)                      
40003608:   b6 10 20 00     clr  %i3                                                      
4000360c:   b4 16 a3 14     or  %i2, 0x314, %i2                                           
        char name [] = RAMDISK_DEVICE_BASE_NAME "a";                                      
40003610:   b0 16 21 76     or  %i0, 0x176, %i0                                           
40003614:   b2 16 60 61     or  %i1, 0x61, %i1                                            
        rc = rtems_blkdev_create(name, c->block_size, c->block_num,                       
40003618:   a2 14 62 e8     or  %l1, 0x2e8, %l1                                           
            r->initialized = true;                                                        
4000361c:   a0 10 20 01     mov  1, %l0                                                   
        char name [] = RAMDISK_DEVICE_BASE_NAME "a";                                      
40003620:   f0 3f bf f0     std  %i0, [ %fp + -16 ]                                       
        name [sizeof(RAMDISK_DEVICE_BASE_NAME) - 1] += i;                                 
40003624:   82 06 e0 61     add  %i3, 0x61, %g1                                           
        r->block_size = c->block_size;                                                    
40003628:   d2 07 00 00     ld  [ %i4 ], %o1                                              
        r->block_num = c->block_num;                                                      
4000362c:   d4 07 20 04     ld  [ %i4 + 4 ], %o2                                          
        name [sizeof(RAMDISK_DEVICE_BASE_NAME) - 1] += i;                                 
40003630:   c2 2f bf f7     stb  %g1, [ %fp + -9 ]                                        
        r->block_size = c->block_size;                                                    
40003634:   d2 27 40 00     st  %o1, [ %i5 ]                                              
        r->block_num = c->block_num;                                                      
40003638:   d4 27 60 04     st  %o2, [ %i5 + 4 ]                                          
        char name [] = RAMDISK_DEVICE_BASE_NAME "a";                                      
4000363c:   c0 2f bf f8     clrb  [ %fp + -8 ]                                            
        if (c->location == NULL)                                                          
40003640:   c2 07 20 08     ld  [ %i4 + 8 ], %g1                                          
40003644:   80 a0 60 00     cmp  %g1, 0                                                   
40003648:   22 80 00 1d     be,a   400036bc <ramdisk_initialize+0xf0>                     
4000364c:   e0 2f 60 0d     stb  %l0, [ %i5 + 0xd ]                                       
            r->malloced = false;                                                          
40003650:   c0 2f 60 0d     clrb  [ %i5 + 0xd ]                                           
            r->initialized = true;                                                        
40003654:   e0 2f 60 0c     stb  %l0, [ %i5 + 0xc ]                                       
            r->area = c->location;                                                        
40003658:   c2 27 60 08     st  %g1, [ %i5 + 8 ]                                          
        rc = rtems_blkdev_create(name, c->block_size, c->block_num,                       
4000365c:   98 10 00 1d     mov  %i5, %o4                                                 
40003660:   96 10 00 11     mov  %l1, %o3                                                 
40003664:   7f ff fd 17     call  40002ac0 <rtems_blkdev_create>                          
40003668:   90 07 bf f0     add  %fp, -16, %o0                                            
                                 ramdisk_ioctl, r);                                       
        if (rc != RTEMS_SUCCESSFUL)                                                       
4000366c:   80 a2 20 00     cmp  %o0, 0                                                   
40003670:   22 80 00 08     be,a   40003690 <ramdisk_initialize+0xc4>                     <== ALWAYS TAKEN
40003674:   b6 06 e0 01     inc  %i3                                                      
        {                                                                                 
            if (r->malloced)                                                              
40003678:   c2 0f 60 0d     ldub  [ %i5 + 0xd ], %g1                                      <== NOT EXECUTED
4000367c:   80 a0 60 00     cmp  %g1, 0                                                   <== NOT EXECUTED
40003680:   12 80 00 0b     bne  400036ac <ramdisk_initialize+0xe0>                       <== NOT EXECUTED
40003684:   01 00 00 00     nop                                                           <== NOT EXECUTED
            {                                                                             
                free(r->area);                                                            
            }                                                                             
            r->initialized = false;                                                       
40003688:   c0 2f 60 0c     clrb  [ %i5 + 0xc ]                                           <== NOT EXECUTED
    for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)                      
4000368c:   b6 06 e0 01     inc  %i3                                                      <== NOT EXECUTED
40003690:   c2 06 80 00     ld  [ %i2 ], %g1                                              
40003694:   b8 07 20 0c     add  %i4, 0xc, %i4                                            
40003698:   80 a0 40 1b     cmp  %g1, %i3                                                 
4000369c:   18 bf ff e1     bgu  40003620 <ramdisk_initialize+0x54>                       
400036a0:   ba 07 60 10     add  %i5, 0x10, %i5                                           
        }                                                                                 
    }                                                                                     
    return RTEMS_SUCCESSFUL;                                                              
}                                                                                         
400036a4:   81 c7 e0 08     ret                                                           
400036a8:   91 e8 20 00     restore  %g0, 0, %o0                                          
                free(r->area);                                                            
400036ac:   40 00 00 fe     call  40003aa4 <free>                                         <== NOT EXECUTED
400036b0:   d0 07 60 08     ld  [ %i5 + 8 ], %o0                                          <== NOT EXECUTED
            r->initialized = false;                                                       
400036b4:   10 bf ff f6     b  4000368c <ramdisk_initialize+0xc0>                         <== NOT EXECUTED
400036b8:   c0 2f 60 0c     clrb  [ %i5 + 0xc ]                                           <== NOT EXECUTED
            r->area = malloc(r->block_size * r->block_num);                               
400036bc:   90 5a 40 0a     smul  %o1, %o2, %o0                                           
400036c0:   d4 27 bf e8     st  %o2, [ %fp + -24 ]                                        
400036c4:   40 00 02 47     call  40003fe0 <malloc>                                       
400036c8:   d2 27 bf ec     st  %o1, [ %fp + -20 ]                                        
400036cc:   d0 27 60 08     st  %o0, [ %i5 + 8 ]                                          
            if (r->area == NULL) /* No enough memory for this disk */                     
400036d0:   80 a2 20 00     cmp  %o0, 0                                                   
400036d4:   d2 07 bf ec     ld  [ %fp + -20 ], %o1                                        
400036d8:   02 bf ff ec     be  40003688 <ramdisk_initialize+0xbc>                        <== NEVER TAKEN
400036dc:   d4 07 bf e8     ld  [ %fp + -24 ], %o2                                        
400036e0:   10 bf ff df     b  4000365c <ramdisk_initialize+0x90>                         
400036e4:   e0 2f 60 0c     stb  %l0, [ %i5 + 0xc ]                                       
                                                                                          
===============================================================================
400036e8 <ramdisk_ioctl>:                                                                 
    return 0;                                                                             
}                                                                                         
                                                                                          
int                                                                                       
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)                            
{                                                                                         
400036e8:   9d e3 bf a0     save  %sp, -96, %sp                                           
    struct ramdisk *rd = rtems_disk_get_driver_data(dd);                                  
                                                                                          
    switch (req)                                                                          
400036ec:   03 08 00 10     sethi  %hi(0x20004000), %g1                                   
                                                                                          
static inline void *rtems_disk_get_driver_data(                                           
  const rtems_disk_device *dd                                                             
)                                                                                         
{                                                                                         
  return dd->driver_data;                                                                 
400036f0:   e0 06 20 3c     ld  [ %i0 + 0x3c ], %l0                                       
400036f4:   82 10 62 07     or  %g1, 0x207, %g1                                           
400036f8:   80 a6 40 01     cmp  %i1, %g1                                                 
400036fc:   02 80 00 25     be  40003790 <ramdisk_ioctl+0xa8>                             
40003700:   b8 10 00 1a     mov  %i2, %i4                                                 
40003704:   03 30 06 10     sethi  %hi(0xc0184000), %g1                                   
40003708:   82 10 62 01     or  %g1, 0x201, %g1 ! c0184201 <RAM_END+0x7fd84201>           
4000370c:   80 a6 40 01     cmp  %i1, %g1                                                 
40003710:   12 80 00 2a     bne  400037b8 <ramdisk_ioctl+0xd0>                            
40003714:   01 00 00 00     nop                                                           
    {                                                                                     
        case RTEMS_BLKIO_REQUEST:                                                         
        {                                                                                 
            rtems_blkdev_request *r = argp;                                               
                                                                                          
            switch (r->req)                                                               
40003718:   f6 06 80 00     ld  [ %i2 ], %i3                                              
4000371c:   80 a6 e0 00     cmp  %i3, 0                                                   
40003720:   02 80 00 2e     be  400037d8 <ramdisk_ioctl+0xf0>                             
40003724:   80 a6 e0 01     cmp  %i3, 1                                                   
40003728:   12 80 00 26     bne  400037c0 <ramdisk_ioctl+0xd8>                            <== NEVER TAKEN
4000372c:   ba 07 20 18     add  %i4, 0x18, %i5                                           
    for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)                               
40003730:   c2 06 a0 10     ld  [ %i2 + 0x10 ], %g1                                       
40003734:   80 a0 60 00     cmp  %g1, 0                                                   
40003738:   02 80 00 0f     be  40003774 <ramdisk_ioctl+0x8c>                             <== NEVER TAKEN
4000373c:   f4 04 20 08     ld  [ %l0 + 8 ], %i2                                          
40003740:   b6 10 20 00     clr  %i3                                                      
        memcpy(to + (sg->block * rd->block_size), sg->buffer, sg->length);                
40003744:   d0 07 40 00     ld  [ %i5 ], %o0                                              
40003748:   c2 04 00 00     ld  [ %l0 ], %g1                                              
4000374c:   d4 07 60 04     ld  [ %i5 + 4 ], %o2                                          
40003750:   d2 07 60 08     ld  [ %i5 + 8 ], %o1                                          
40003754:   90 5a 00 01     smul  %o0, %g1, %o0                                           
40003758:   40 00 47 90     call  40015598 <memcpy>                                       
4000375c:   90 06 80 08     add  %i2, %o0, %o0                                            
    for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)                               
40003760:   c2 07 20 10     ld  [ %i4 + 0x10 ], %g1                                       
40003764:   b6 06 e0 01     inc  %i3                                                      
40003768:   80 a6 c0 01     cmp  %i3, %g1                                                 
4000376c:   0a bf ff f6     bcs  40003744 <ramdisk_ioctl+0x5c>                            
40003770:   ba 07 60 10     add  %i5, 0x10, %i5                                           
  (*req->done)(req, status);                                                              
40003774:   c2 07 20 04     ld  [ %i4 + 4 ], %g1                                          
40003778:   92 10 20 00     clr  %o1                                                      
4000377c:   90 10 00 1c     mov  %i4, %o0                                                 
40003780:   9f c0 40 00     call  %g1                                                     
40003784:   b0 10 20 00     clr  %i0                                                      
            {                                                                             
                case RTEMS_BLKDEV_REQ_READ:                                               
                    return ramdisk_read(rd, r);                                           
                                                                                          
                case RTEMS_BLKDEV_REQ_WRITE:                                              
                    return ramdisk_write(rd, r);                                          
40003788:   81 c7 e0 08     ret                                                           
4000378c:   81 e8 00 00     restore                                                       
            }                                                                             
            break;                                                                        
        }                                                                                 
                                                                                          
        case RTEMS_BLKIO_DELETED:                                                         
            if (rd->free_at_delete_request) {                                             
40003790:   c2 0c 20 0f     ldub  [ %l0 + 0xf ], %g1                                      
40003794:   80 a0 60 00     cmp  %g1, 0                                                   
40003798:   12 80 00 23     bne  40003824 <ramdisk_ioctl+0x13c>                           
4000379c:   01 00 00 00     nop                                                           
        default:                                                                          
            return rtems_blkdev_ioctl (dd, req, argp);                                    
            break;                                                                        
    }                                                                                     
                                                                                          
    errno = EINVAL;                                                                       
400037a0:   40 00 46 5c     call  40015110 <__errno>                                      
400037a4:   b0 10 3f ff     mov  -1, %i0    ! ffffffff <RAM_END+0xbfbfffff>               
400037a8:   82 10 20 16     mov  0x16, %g1                                                
400037ac:   c2 22 00 00     st  %g1, [ %o0 ]                                              
    return -1;                                                                            
}                                                                                         
400037b0:   81 c7 e0 08     ret                                                           
400037b4:   81 e8 00 00     restore                                                       
            return rtems_blkdev_ioctl (dd, req, argp);                                    
400037b8:   40 00 2f b7     call  4000f694 <rtems_blkdev_ioctl>                           
400037bc:   81 e8 00 00     restore                                                       
                    errno = EINVAL;                                                       
400037c0:   40 00 46 54     call  40015110 <__errno>                                      <== NOT EXECUTED
400037c4:   b0 10 3f ff     mov  -1, %i0                                                  <== NOT EXECUTED
400037c8:   82 10 20 16     mov  0x16, %g1                                                <== NOT EXECUTED
400037cc:   c2 22 00 00     st  %g1, [ %o0 ]                                              <== NOT EXECUTED
                    return -1;                                                            
400037d0:   81 c7 e0 08     ret                                                           <== NOT EXECUTED
400037d4:   81 e8 00 00     restore                                                       <== NOT EXECUTED
    for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)                               
400037d8:   c2 06 a0 10     ld  [ %i2 + 0x10 ], %g1                                       
400037dc:   ba 07 20 18     add  %i4, 0x18, %i5                                           
400037e0:   80 a0 60 00     cmp  %g1, 0                                                   
400037e4:   02 bf ff e4     be  40003774 <ramdisk_ioctl+0x8c>                             <== NEVER TAKEN
400037e8:   f4 04 20 08     ld  [ %l0 + 8 ], %i2                                          
        memcpy(sg->buffer, from + (sg->block * rd->block_size), sg->length);              
400037ec:   d2 07 40 00     ld  [ %i5 ], %o1                                              
400037f0:   c2 04 00 00     ld  [ %l0 ], %g1                                              
400037f4:   d4 07 60 04     ld  [ %i5 + 4 ], %o2                                          
400037f8:   d0 07 60 08     ld  [ %i5 + 8 ], %o0                                          
400037fc:   92 5a 40 01     smul  %o1, %g1, %o1                                           
40003800:   40 00 47 66     call  40015598 <memcpy>                                       
40003804:   92 06 80 09     add  %i2, %o1, %o1                                            
    for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)                               
40003808:   c2 07 20 10     ld  [ %i4 + 0x10 ], %g1                                       
4000380c:   b6 06 e0 01     inc  %i3                                                      
40003810:   80 a6 c0 01     cmp  %i3, %g1                                                 
40003814:   0a bf ff f6     bcs  400037ec <ramdisk_ioctl+0x104>                           <== NEVER TAKEN
40003818:   ba 07 60 10     add  %i5, 0x10, %i5                                           
4000381c:   10 bf ff d7     b  40003778 <ramdisk_ioctl+0x90>                              
40003820:   c2 07 20 04     ld  [ %i4 + 4 ], %g1                                          
              ramdisk_free(rd);                                                           
40003824:   40 00 00 08     call  40003844 <ramdisk_free>                                 
40003828:   90 10 00 10     mov  %l0, %o0                                                 
    errno = EINVAL;                                                                       
4000382c:   40 00 46 39     call  40015110 <__errno>                                      
40003830:   b0 10 3f ff     mov  -1, %i0                                                  
40003834:   82 10 20 16     mov  0x16, %g1                                                
40003838:   c2 22 00 00     st  %g1, [ %o0 ]                                              
}                                                                                         
4000383c:   81 c7 e0 08     ret                                                           
40003840:   81 e8 00 00     restore                                                       
                                                                                          
===============================================================================
40002d48 <ramdisk_register>:                                                              
  uint32_t media_block_size,                                                              
  rtems_blkdev_bnum media_block_count,                                                    
  bool trace,                                                                             
  const char *disk                                                                        
)                                                                                         
{                                                                                         
40002d48:   9d e3 bf a0     save  %sp, -96, %sp                                           
  rtems_status_code sc = RTEMS_SUCCESSFUL;                                                
  ramdisk *rd = NULL;                                                                     
                                                                                          
  rd = ramdisk_allocate(NULL, media_block_size, media_block_count, trace);                
40002d4c:   90 10 20 00     clr  %o0                                                      
40002d50:   96 10 00 1a     mov  %i2, %o3                                                 
40002d54:   94 10 00 19     mov  %i1, %o2                                                 
40002d58:   40 00 3f 67     call  40012af4 <ramdisk_allocate>                             
40002d5c:   92 10 00 18     mov  %i0, %o1                                                 
  if (rd == NULL) {                                                                       
40002d60:   ba 92 20 00     orcc  %o0, 0, %i5                                             
40002d64:   02 80 00 0f     be  40002da0 <ramdisk_register+0x58>                          <== NEVER TAKEN
40002d68:   92 10 00 18     mov  %i0, %o1                                                 
    return RTEMS_UNSATISFIED;                                                             
  }                                                                                       
                                                                                          
  sc = rtems_blkdev_create(                                                               
40002d6c:   98 10 00 1d     mov  %i5, %o4                                                 
40002d70:   94 10 00 19     mov  %i1, %o2                                                 
40002d74:   17 10 00 4a     sethi  %hi(0x40012800), %o3                                   
40002d78:   90 10 00 1b     mov  %i3, %o0                                                 
40002d7c:   40 00 3e c4     call  4001288c <rtems_blkdev_create>                          
40002d80:   96 12 e1 98     or  %o3, 0x198, %o3                                           
    media_block_size,                                                                     
    media_block_count,                                                                    
    ramdisk_ioctl,                                                                        
    rd                                                                                    
  );                                                                                      
  if (sc != RTEMS_SUCCESSFUL) {                                                           
40002d84:   b0 92 20 00     orcc  %o0, 0, %i0                                             
40002d88:   02 80 00 04     be  40002d98 <ramdisk_register+0x50>                          <== ALWAYS TAKEN
40002d8c:   90 10 00 1d     mov  %i5, %o0                                                 
    ramdisk_free(rd);                                                                     
40002d90:   40 00 3f 75     call  40012b64 <ramdisk_free>                                 <== NOT EXECUTED
40002d94:   b0 10 20 0d     mov  0xd, %i0                                                 <== NOT EXECUTED
                                                                                          
    return RTEMS_UNSATISFIED;                                                             
40002d98:   81 c7 e0 08     ret                                                           
40002d9c:   81 e8 00 00     restore                                                       
  }                                                                                       
                                                                                          
  return RTEMS_SUCCESSFUL;                                                                
}                                                                                         
40002da0:   81 c7 e0 08     ret                                                           <== NOT EXECUTED
40002da4:   91 e8 20 0d     restore  %g0, 0xd, %o0                                        <== NOT EXECUTED
                                                                                          
===============================================================================
4000ed94 <rtems_bdbuf_get>:                                                               
{                                                                                         
4000ed94:   9d e3 bf a0     save  %sp, -96, %sp                                           
4000ed98:   39 10 00 93     sethi  %hi(0x40024c00), %i4                                   
4000ed9c:   7f ff ea 82     call  400097a4 <_Mutex_Acquire>                               
4000eda0:   90 17 22 70     or  %i4, 0x270, %o0 ! 40024e70 <bdbuf_cache+0x28>             
  if (block < dd->block_count)                                                            
4000eda4:   c2 06 20 28     ld  [ %i0 + 0x28 ], %g1                                       
4000eda8:   80 a6 40 01     cmp  %i1, %g1                                                 
4000edac:   1a 80 00 31     bcc  4000ee70 <rtems_bdbuf_get+0xdc>                          <== NEVER TAKEN
4000edb0:   ba 10 20 00     clr  %i5                                                      
  if (dd->block_to_media_block_shift >= 0)                                                
4000edb4:   d2 06 20 30     ld  [ %i0 + 0x30 ], %o1                                       
4000edb8:   80 a2 60 00     cmp  %o1, 0                                                   
4000edbc:   06 80 00 16     bl  4000ee14 <rtems_bdbuf_get+0x80>                           <== NEVER TAKEN
4000edc0:   93 2e 40 09     sll  %i1, %o1, %o1                                            
    *media_block_ptr = rtems_bdbuf_media_block (dd, block) + dd->start;                   
4000edc4:   c2 06 20 18     ld  [ %i0 + 0x18 ], %g1                                       
    bd = rtems_bdbuf_get_buffer_for_access (dd, media_block);                             
4000edc8:   90 10 00 18     mov  %i0, %o0                                                 
4000edcc:   7f ff ff 05     call  4000e9e0 <rtems_bdbuf_get_buffer_for_access>            
4000edd0:   92 02 40 01     add  %o1, %g1, %o1                                            
4000edd4:   ba 10 00 08     mov  %o0, %i5                                                 
    switch (bd->state)                                                                    
4000edd8:   d0 02 20 20     ld  [ %o0 + 0x20 ], %o0                                       
4000eddc:   80 a2 20 02     cmp  %o0, 2                                                   
4000ede0:   02 80 00 1d     be  4000ee54 <rtems_bdbuf_get+0xc0>                           
4000ede4:   82 10 20 03     mov  3, %g1                                                   
4000ede8:   80 a2 20 07     cmp  %o0, 7                                                   
4000edec:   12 80 00 1d     bne  4000ee60 <rtems_bdbuf_get+0xcc>                          
4000edf0:   80 a2 20 01     cmp  %o0, 1                                                   
  bd->state = state;                                                                      
4000edf4:   82 10 20 04     mov  4, %g1                                                   
4000edf8:   c2 27 60 20     st  %g1, [ %i5 + 0x20 ]                                       
}                                                                                         
4000edfc:   b0 10 20 00     clr  %i0                                                      
  _Mutex_Release( mutex );                                                                
4000ee00:   7f ff ea 84     call  40009810 <_Mutex_Release>                               
4000ee04:   90 17 22 70     or  %i4, 0x270, %o0                                           
  *bd_ptr = bd;                                                                           
4000ee08:   fa 26 80 00     st  %i5, [ %i2 ]                                              
}                                                                                         
4000ee0c:   81 c7 e0 08     ret                                                           
4000ee10:   81 e8 00 00     restore                                                       
      ((((uint64_t) block) * dd->block_size) / dd->media_block_size);                     
4000ee14:   d0 06 20 24     ld  [ %i0 + 0x24 ], %o0                                       <== NOT EXECUTED
4000ee18:   d6 06 20 20     ld  [ %i0 + 0x20 ], %o3                                       <== NOT EXECUTED
4000ee1c:   92 56 40 08     umul  %i1, %o0, %o1                                           <== NOT EXECUTED
4000ee20:   91 40 00 00     rd  %y, %o0                                                   <== NOT EXECUTED
4000ee24:   40 00 17 6e     call  40014bdc <__udivdi3>                                    <== NOT EXECUTED
4000ee28:   94 10 20 00     clr  %o2                                                      <== NOT EXECUTED
    *media_block_ptr = rtems_bdbuf_media_block (dd, block) + dd->start;                   
4000ee2c:   c2 06 20 18     ld  [ %i0 + 0x18 ], %g1                                       <== NOT EXECUTED
    bd = rtems_bdbuf_get_buffer_for_access (dd, media_block);                             
4000ee30:   92 02 40 01     add  %o1, %g1, %o1                                            <== NOT EXECUTED
4000ee34:   7f ff fe eb     call  4000e9e0 <rtems_bdbuf_get_buffer_for_access>            <== NOT EXECUTED
4000ee38:   90 10 00 18     mov  %i0, %o0                                                 <== NOT EXECUTED
4000ee3c:   ba 10 00 08     mov  %o0, %i5                                                 <== NOT EXECUTED
    switch (bd->state)                                                                    
4000ee40:   d0 02 20 20     ld  [ %o0 + 0x20 ], %o0                                       <== NOT EXECUTED
4000ee44:   80 a2 20 02     cmp  %o0, 2                                                   <== NOT EXECUTED
4000ee48:   12 bf ff e9     bne  4000edec <rtems_bdbuf_get+0x58>                          <== NOT EXECUTED
4000ee4c:   80 a2 20 07     cmp  %o0, 7                                                   <== NOT EXECUTED
  bd->state = state;                                                                      
4000ee50:   82 10 20 03     mov  3, %g1                                                   <== NOT EXECUTED
}                                                                                         
4000ee54:   b0 10 20 00     clr  %i0                                                      
4000ee58:   10 bf ff ea     b  4000ee00 <rtems_bdbuf_get+0x6c>                            
4000ee5c:   c2 27 60 20     st  %g1, [ %i5 + 0x20 ]                                       
    switch (bd->state)                                                                    
4000ee60:   02 80 00 0a     be  4000ee88 <rtems_bdbuf_get+0xf4>                           <== ALWAYS TAKEN
4000ee64:   82 10 20 05     mov  5, %g1                                                   
        rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_2);              
4000ee68:   7f ff f7 a4     call  4000ccf8 <rtems_bdbuf_fatal_with_state>                 <== NOT EXECUTED
4000ee6c:   92 10 20 0a     mov  0xa, %o1                                                 <== NOT EXECUTED
4000ee70:   90 17 22 70     or  %i4, 0x270, %o0                                           <== NOT EXECUTED
4000ee74:   7f ff ea 67     call  40009810 <_Mutex_Release>                               <== NOT EXECUTED
4000ee78:   b0 10 20 04     mov  4, %i0                                                   <== NOT EXECUTED
  *bd_ptr = bd;                                                                           
4000ee7c:   fa 26 80 00     st  %i5, [ %i2 ]                                              <== NOT EXECUTED
}                                                                                         
4000ee80:   81 c7 e0 08     ret                                                           <== NOT EXECUTED
4000ee84:   81 e8 00 00     restore                                                       <== NOT EXECUTED
}                                                                                         
4000ee88:   b0 10 20 00     clr  %i0                                                      
4000ee8c:   10 bf ff dd     b  4000ee00 <rtems_bdbuf_get+0x6c>                            
4000ee90:   c2 27 60 20     st  %g1, [ %i5 + 0x20 ]                                       
                                                                                          
===============================================================================
4000ee94 <rtems_bdbuf_read>:                                                              
{                                                                                         
4000ee94:   9d e3 bf a0     save  %sp, -96, %sp                                           
  _Mutex_Acquire( mutex );                                                                
4000ee98:   37 10 00 93     sethi  %hi(0x40024c00), %i3                                   
4000ee9c:   7f ff ea 42     call  400097a4 <_Mutex_Acquire>                               
4000eea0:   90 16 e2 70     or  %i3, 0x270, %o0 ! 40024e70 <bdbuf_cache+0x28>             
  if (block < dd->block_count)                                                            
4000eea4:   c2 06 20 28     ld  [ %i0 + 0x28 ], %g1                                       
4000eea8:   80 a6 40 01     cmp  %i1, %g1                                                 
4000eeac:   1a 80 00 41     bcc  4000efb0 <rtems_bdbuf_read+0x11c>                        <== NEVER TAKEN
4000eeb0:   ba 10 00 18     mov  %i0, %i5                                                 
  if (dd->block_to_media_block_shift >= 0)                                                
4000eeb4:   d2 06 20 30     ld  [ %i0 + 0x30 ], %o1                                       
4000eeb8:   80 a2 60 00     cmp  %o1, 0                                                   
4000eebc:   06 80 00 23     bl  4000ef48 <rtems_bdbuf_read+0xb4>                          <== NEVER TAKEN
4000eec0:   93 2e 40 09     sll  %i1, %o1, %o1                                            
    *media_block_ptr = rtems_bdbuf_media_block (dd, block) + dd->start;                   
4000eec4:   c2 07 60 18     ld  [ %i5 + 0x18 ], %g1                                       
    bd = rtems_bdbuf_get_buffer_for_access (dd, media_block);                             
4000eec8:   90 10 00 1d     mov  %i5, %o0                                                 
4000eecc:   7f ff fe c5     call  4000e9e0 <rtems_bdbuf_get_buffer_for_access>            
4000eed0:   92 02 40 01     add  %o1, %g1, %o1                                            
4000eed4:   b8 10 00 08     mov  %o0, %i4                                                 
    switch (bd->state)                                                                    
4000eed8:   d0 02 20 20     ld  [ %o0 + 0x20 ], %o0                                       
4000eedc:   80 a2 20 02     cmp  %o0, 2                                                   
4000eee0:   22 80 00 2a     be,a   4000ef88 <rtems_bdbuf_read+0xf4>                       
4000eee4:   c2 07 60 44     ld  [ %i5 + 0x44 ], %g1                                       
4000eee8:   80 a2 20 07     cmp  %o0, 7                                                   
4000eeec:   12 80 00 2d     bne  4000efa0 <rtems_bdbuf_read+0x10c>                        
4000eef0:   80 a2 20 01     cmp  %o0, 1                                                   
        ++dd->stats.read_hits;                                                            
4000eef4:   c2 07 60 44     ld  [ %i5 + 0x44 ], %g1                                       
4000eef8:   82 00 60 01     inc  %g1                                                      
4000eefc:   c2 27 60 44     st  %g1, [ %i5 + 0x44 ]                                       
  bd->state = state;                                                                      
4000ef00:   82 10 20 04     mov  4, %g1                                                   
4000ef04:   c2 27 20 20     st  %g1, [ %i4 + 0x20 ]                                       
}                                                                                         
4000ef08:   b0 10 20 00     clr  %i0                                                      
  if (bdbuf_cache.read_ahead_task != 0                                                    
4000ef0c:   21 10 00 93     sethi  %hi(0x40024c00), %l0                                   
4000ef10:   a0 14 22 48     or  %l0, 0x248, %l0 ! 40024e48 <bdbuf_cache>                  
4000ef14:   d0 04 20 dc     ld  [ %l0 + 0xdc ], %o0                                       
4000ef18:   80 a2 20 00     cmp  %o0, 0                                                   
4000ef1c:   02 80 00 06     be  4000ef34 <rtems_bdbuf_read+0xa0>                          
4000ef20:   01 00 00 00     nop                                                           
      && dd->read_ahead.trigger == block                                                  
4000ef24:   c2 07 60 6c     ld  [ %i5 + 0x6c ], %g1                                       
4000ef28:   80 a6 40 01     cmp  %i1, %g1                                                 
4000ef2c:   22 80 00 4c     be,a   4000f05c <rtems_bdbuf_read+0x1c8>                      
4000ef30:   c2 07 60 64     ld  [ %i5 + 0x64 ], %g1                                       
  _Mutex_Release( mutex );                                                                
4000ef34:   7f ff ea 37     call  40009810 <_Mutex_Release>                               
4000ef38:   90 16 e2 70     or  %i3, 0x270, %o0                                           
  *bd_ptr = bd;                                                                           
4000ef3c:   f8 26 80 00     st  %i4, [ %i2 ]                                              
}                                                                                         
4000ef40:   81 c7 e0 08     ret                                                           
4000ef44:   81 e8 00 00     restore                                                       
      ((((uint64_t) block) * dd->block_size) / dd->media_block_size);                     
4000ef48:   d0 06 20 24     ld  [ %i0 + 0x24 ], %o0                                       <== NOT EXECUTED
4000ef4c:   d6 06 20 20     ld  [ %i0 + 0x20 ], %o3                                       <== NOT EXECUTED
4000ef50:   92 56 40 08     umul  %i1, %o0, %o1                                           <== NOT EXECUTED
4000ef54:   91 40 00 00     rd  %y, %o0                                                   <== NOT EXECUTED
4000ef58:   40 00 17 21     call  40014bdc <__udivdi3>                                    <== NOT EXECUTED
4000ef5c:   94 10 20 00     clr  %o2                                                      <== NOT EXECUTED
    *media_block_ptr = rtems_bdbuf_media_block (dd, block) + dd->start;                   
4000ef60:   c2 07 60 18     ld  [ %i5 + 0x18 ], %g1                                       <== NOT EXECUTED
    bd = rtems_bdbuf_get_buffer_for_access (dd, media_block);                             
4000ef64:   92 02 40 01     add  %o1, %g1, %o1                                            <== NOT EXECUTED
4000ef68:   7f ff fe 9e     call  4000e9e0 <rtems_bdbuf_get_buffer_for_access>            <== NOT EXECUTED
4000ef6c:   90 10 00 1d     mov  %i5, %o0                                                 <== NOT EXECUTED
4000ef70:   b8 10 00 08     mov  %o0, %i4                                                 <== NOT EXECUTED
    switch (bd->state)                                                                    
4000ef74:   d0 02 20 20     ld  [ %o0 + 0x20 ], %o0                                       <== NOT EXECUTED
4000ef78:   80 a2 20 02     cmp  %o0, 2                                                   <== NOT EXECUTED
4000ef7c:   12 bf ff dc     bne  4000eeec <rtems_bdbuf_read+0x58>                         <== NOT EXECUTED
4000ef80:   80 a2 20 07     cmp  %o0, 7                                                   <== NOT EXECUTED
        ++dd->stats.read_hits;                                                            
4000ef84:   c2 07 60 44     ld  [ %i5 + 0x44 ], %g1                                       <== NOT EXECUTED
4000ef88:   82 00 60 01     inc  %g1                                                      
4000ef8c:   c2 27 60 44     st  %g1, [ %i5 + 0x44 ]                                       
}                                                                                         
4000ef90:   b0 10 20 00     clr  %i0                                                      
  bd->state = state;                                                                      
4000ef94:   82 10 20 03     mov  3, %g1                                                   
}                                                                                         
4000ef98:   10 bf ff dd     b  4000ef0c <rtems_bdbuf_read+0x78>                           
4000ef9c:   c2 27 20 20     st  %g1, [ %i4 + 0x20 ]                                       
    switch (bd->state)                                                                    
4000efa0:   22 80 00 0b     be,a   4000efcc <rtems_bdbuf_read+0x138>                      <== ALWAYS TAKEN
4000efa4:   c2 07 60 48     ld  [ %i5 + 0x48 ], %g1                                       
        rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_4);              
4000efa8:   7f ff f7 54     call  4000ccf8 <rtems_bdbuf_fatal_with_state>                 <== NOT EXECUTED
4000efac:   92 10 20 0b     mov  0xb, %o1                                                 <== NOT EXECUTED
  rtems_bdbuf_buffer   *bd = NULL;                                                        
4000efb0:   b8 10 20 00     clr  %i4                                                      <== NOT EXECUTED
4000efb4:   90 16 e2 70     or  %i3, 0x270, %o0                                           <== NOT EXECUTED
4000efb8:   7f ff ea 16     call  40009810 <_Mutex_Release>                               <== NOT EXECUTED
4000efbc:   b0 10 20 04     mov  4, %i0                                                   <== NOT EXECUTED
  *bd_ptr = bd;                                                                           
4000efc0:   f8 26 80 00     st  %i4, [ %i2 ]                                              <== NOT EXECUTED
}                                                                                         
4000efc4:   81 c7 e0 08     ret                                                           <== NOT EXECUTED
4000efc8:   81 e8 00 00     restore                                                       <== NOT EXECUTED
        ++dd->stats.read_misses;                                                          
4000efcc:   82 00 60 01     inc  %g1                                                      
4000efd0:   c2 27 60 48     st  %g1, [ %i5 + 0x48 ]                                       
  if (dd->read_ahead.trigger != block)                                                    
4000efd4:   c2 07 60 6c     ld  [ %i5 + 0x6c ], %g1                                       
4000efd8:   80 a6 40 01     cmp  %i1, %g1                                                 
4000efdc:   02 80 00 0f     be  4000f018 <rtems_bdbuf_read+0x184>                         
4000efe0:   94 10 20 01     mov  1, %o2                                                   
  return node->next == NULL;                                                              
4000efe4:   c2 07 60 64     ld  [ %i5 + 0x64 ], %g1                                       
  if (rtems_bdbuf_is_read_ahead_active (dd))                                              
4000efe8:   80 a0 60 00     cmp  %g1, 0                                                   
4000efec:   02 80 00 07     be  4000f008 <rtems_bdbuf_read+0x174>                         <== ALWAYS TAKEN
4000eff0:   84 06 60 01     add  %i1, 1, %g2                                              
  previous       = the_node->previous;                                                    
4000eff4:   c4 07 60 68     ld  [ %i5 + 0x68 ], %g2                                       <== NOT EXECUTED
  next->previous = previous;                                                              
4000eff8:   c4 20 60 04     st  %g2, [ %g1 + 4 ]                                          <== NOT EXECUTED
  previous->next = next;                                                                  
4000effc:   c2 20 80 00     st  %g1, [ %g2 ]                                              <== NOT EXECUTED
  node->next = NULL;                                                                      
4000f000:   c0 27 60 64     clr  [ %i5 + 0x64 ]                                           <== NOT EXECUTED
    dd->read_ahead.trigger = block + 1;                                                   
4000f004:   84 06 60 01     add  %i1, 1, %g2                                              <== NOT EXECUTED
    dd->read_ahead.next = block + 2;                                                      
4000f008:   82 06 60 02     add  %i1, 2, %g1                                              
    dd->read_ahead.trigger = block + 1;                                                   
4000f00c:   c4 27 60 6c     st  %g2, [ %i5 + 0x6c ]                                       
    dd->read_ahead.next = block + 2;                                                      
4000f010:   c2 27 60 70     st  %g1, [ %i5 + 0x70 ]                                       
        sc = rtems_bdbuf_execute_read_request (dd, bd, 1);                                
4000f014:   94 10 20 01     mov  1, %o2                                                   
4000f018:   92 10 00 1c     mov  %i4, %o1                                                 
4000f01c:   7f ff fc 29     call  4000e0c0 <rtems_bdbuf_execute_read_request>             
4000f020:   90 10 00 1d     mov  %i5, %o0                                                 
        if (sc == RTEMS_SUCCESSFUL)                                                       
4000f024:   b0 92 20 00     orcc  %o0, 0, %i0                                             
4000f028:   32 bf ff b9     bne,a   4000ef0c <rtems_bdbuf_read+0x78>                      
4000f02c:   b8 10 20 00     clr  %i4                                                      
  next           = the_node->next;                                                        
4000f030:   c8 07 00 00     ld  [ %i4 ], %g4                                              
  previous       = the_node->previous;                                                    
4000f034:   c6 07 20 04     ld  [ %i4 + 4 ], %g3                                          
  bd->state = state;                                                                      
4000f038:   82 10 20 03     mov  3, %g1                                                   
4000f03c:   c2 27 20 20     st  %g1, [ %i4 + 0x20 ]                                       
  ++bd->group->users;                                                                     
4000f040:   c4 07 20 28     ld  [ %i4 + 0x28 ], %g2                                       
  next->previous = previous;                                                              
4000f044:   c6 21 20 04     st  %g3, [ %g4 + 4 ]                                          
4000f048:   c2 00 a0 0c     ld  [ %g2 + 0xc ], %g1                                        
  previous->next = next;                                                                  
4000f04c:   c8 20 c0 00     st  %g4, [ %g3 ]                                              
4000f050:   82 00 60 01     inc  %g1                                                      
}                                                                                         
4000f054:   10 bf ff ae     b  4000ef0c <rtems_bdbuf_read+0x78>                           
4000f058:   c2 20 a0 0c     st  %g1, [ %g2 + 0xc ]                                        
      && !rtems_bdbuf_is_read_ahead_active (dd))                                          
4000f05c:   80 a0 60 00     cmp  %g1, 0                                                   
4000f060:   12 bf ff b5     bne  4000ef34 <rtems_bdbuf_read+0xa0>                         <== NEVER TAKEN
4000f064:   b2 04 20 e4     add  %l0, 0xe4, %i1                                           
    if (rtems_chain_is_empty (chain))                                                     
4000f068:   c2 04 20 e0     ld  [ %l0 + 0xe0 ], %g1                                       
4000f06c:   80 a0 40 19     cmp  %g1, %i1                                                 
4000f070:   02 80 00 09     be  4000f094 <rtems_bdbuf_read+0x200>                         <== ALWAYS TAKEN
4000f074:   01 00 00 00     nop                                                           
  old_last = tail->previous;                                                              
4000f078:   c2 04 20 e8     ld  [ %l0 + 0xe8 ], %g1                                       <== NOT EXECUTED
  the_node->next = tail;                                                                  
4000f07c:   f2 27 60 64     st  %i1, [ %i5 + 0x64 ]                                       
    rtems_chain_append_unprotected (chain, &dd->read_ahead.node);                         
4000f080:   84 07 60 64     add  %i5, 0x64, %g2                                           
  tail->previous = the_node;                                                              
4000f084:   c4 24 20 e8     st  %g2, [ %l0 + 0xe8 ]                                       
  old_last->next = the_node;                                                              
4000f088:   c4 20 40 00     st  %g2, [ %g1 ]                                              
4000f08c:   10 bf ff aa     b  4000ef34 <rtems_bdbuf_read+0xa0>                           
4000f090:   c2 27 60 68     st  %g1, [ %i5 + 0x68 ]                                       
      sc = rtems_event_send (bdbuf_cache.read_ahead_task,                                 
4000f094:   40 00 05 1f     call  40010510 <rtems_event_send>                             
4000f098:   92 10 20 02     mov  2, %o1                                                   
      if (sc != RTEMS_SUCCESSFUL)                                                         
4000f09c:   80 a2 20 00     cmp  %o0, 0                                                   
4000f0a0:   22 bf ff f7     be,a   4000f07c <rtems_bdbuf_read+0x1e8>                      <== ALWAYS TAKEN
4000f0a4:   c2 04 20 e8     ld  [ %l0 + 0xe8 ], %g1                                       
        rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_RA_WAKE_UP);                                 
4000f0a8:   7f ff f7 0f     call  4000cce4 <rtems_bdbuf_fatal>                            <== NOT EXECUTED
4000f0ac:   90 10 20 05     mov  5, %o0                                                   <== NOT EXECUTED
4000f0b0:   01 00 00 00     nop                                                           <== NOT EXECUTED
                                                                                          
===============================================================================
4000f0b4 <rtems_bdbuf_release>:                                                           
{                                                                                         
4000f0b4:   9d e3 bf a0     save  %sp, -96, %sp                                           
  if (bd == NULL)                                                                         
4000f0b8:   80 a6 20 00     cmp  %i0, 0                                                   
4000f0bc:   02 80 00 40     be  4000f1bc <rtems_bdbuf_release+0x108>                      <== NEVER TAKEN
4000f0c0:   01 00 00 00     nop                                                           
  _Mutex_Acquire( mutex );                                                                
4000f0c4:   3b 10 00 93     sethi  %hi(0x40024c00), %i5                                   
4000f0c8:   7f ff e9 b7     call  400097a4 <_Mutex_Acquire>                               
4000f0cc:   90 17 62 70     or  %i5, 0x270, %o0 ! 40024e70 <bdbuf_cache+0x28>             
  switch (bd->state)                                                                      
4000f0d0:   d0 06 20 20     ld  [ %i0 + 0x20 ], %o0                                       
4000f0d4:   80 a2 20 04     cmp  %o0, 4                                                   
4000f0d8:   02 80 00 2b     be  4000f184 <rtems_bdbuf_release+0xd0>                       
4000f0dc:   01 00 00 00     nop                                                           
4000f0e0:   08 80 00 0d     bleu  4000f114 <rtems_bdbuf_release+0x60>                     
4000f0e4:   80 a2 20 03     cmp  %o0, 3                                                   
4000f0e8:   82 02 3f fb     add  %o0, -5, %g1                                             
4000f0ec:   80 a0 60 01     cmp  %g1, 1                                                   
4000f0f0:   18 80 00 35     bgu  4000f1c4 <rtems_bdbuf_release+0x110>                     <== NEVER TAKEN
4000f0f4:   01 00 00 00     nop                                                           
      rtems_bdbuf_discard_buffer_after_access (bd);                                       
4000f0f8:   7f ff f8 0f     call  4000d134 <rtems_bdbuf_discard_buffer_after_access>      
4000f0fc:   90 10 00 18     mov  %i0, %o0                                                 
  _Mutex_Release( mutex );                                                                
4000f100:   90 17 62 70     or  %i5, 0x270, %o0                                           
4000f104:   7f ff e9 c3     call  40009810 <_Mutex_Release>                               
4000f108:   b0 10 20 00     clr  %i0                                                      
  return RTEMS_SUCCESSFUL;                                                                
4000f10c:   81 c7 e0 08     ret                                                           
4000f110:   81 e8 00 00     restore                                                       
  switch (bd->state)                                                                      
4000f114:   12 80 00 2c     bne  4000f1c4 <rtems_bdbuf_release+0x110>                     <== NEVER TAKEN
4000f118:   01 00 00 00     nop                                                           
  --bd->group->users;                                                                     
4000f11c:   c4 06 20 28     ld  [ %i0 + 0x28 ], %g2                                       
4000f120:   c2 00 a0 0c     ld  [ %g2 + 0xc ], %g1                                        
4000f124:   82 00 7f ff     add  %g1, -1, %g1                                             
4000f128:   c2 20 a0 0c     st  %g1, [ %g2 + 0xc ]                                        
  bd->state = state;                                                                      
4000f12c:   82 10 20 02     mov  2, %g1                                                   
  old_last = tail->previous;                                                              
4000f130:   11 10 00 93     sethi  %hi(0x40024c00), %o0                                   
4000f134:   c2 26 20 20     st  %g1, [ %i0 + 0x20 ]                                       
4000f138:   90 12 22 48     or  %o0, 0x248, %o0                                           
4000f13c:   c2 02 20 68     ld  [ %o0 + 0x68 ], %g1                                       
  the_node->next = tail;                                                                  
4000f140:   84 02 20 64     add  %o0, 0x64, %g2                                           
4000f144:   c4 26 00 00     st  %g2, [ %i0 ]                                              
  tail->previous = the_node;                                                              
4000f148:   f0 22 20 68     st  %i0, [ %o0 + 0x68 ]                                       
  old_last->next = the_node;                                                              
4000f14c:   f0 20 40 00     st  %i0, [ %g1 ]                                              
  the_node->previous = old_last;                                                          
4000f150:   c2 26 20 04     st  %g1, [ %i0 + 4 ]                                          
  if (bd->waiters)                                                                        
4000f154:   c2 06 20 24     ld  [ %i0 + 0x24 ], %g1                                       
4000f158:   80 a0 60 00     cmp  %g1, 0                                                   
4000f15c:   22 80 00 11     be,a   4000f1a0 <rtems_bdbuf_release+0xec>                    
4000f160:   c2 02 20 b4     ld  [ %o0 + 0xb4 ], %g1                                       
  if (waiters->count > 0)                                                                 
4000f164:   c2 02 20 84     ld  [ %o0 + 0x84 ], %g1                                       
4000f168:   80 a0 60 00     cmp  %g1, 0                                                   
4000f16c:   22 bf ff e6     be,a   4000f104 <rtems_bdbuf_release+0x50>                    
4000f170:   90 17 62 70     or  %i5, 0x270, %o0                                           
  _Condition_Broadcast( condition_variable );                                             
4000f174:   40 00 05 e6     call  4001090c <_Condition_Broadcast>                         
4000f178:   90 02 20 88     add  %o0, 0x88, %o0                                           
}                                                                                         
4000f17c:   10 bf ff e2     b  4000f104 <rtems_bdbuf_release+0x50>                        
4000f180:   90 17 62 70     or  %i5, 0x270, %o0                                           
      rtems_bdbuf_add_to_modified_list_after_access (bd);                                 
4000f184:   7f ff fe be     call  4000ec7c <rtems_bdbuf_add_to_modified_list_after_access>
4000f188:   90 10 00 18     mov  %i0, %o0                                                 
  _Mutex_Release( mutex );                                                                
4000f18c:   90 17 62 70     or  %i5, 0x270, %o0                                           
4000f190:   7f ff e9 a0     call  40009810 <_Mutex_Release>                               
4000f194:   b0 10 20 00     clr  %i0                                                      
  return RTEMS_SUCCESSFUL;                                                                
4000f198:   81 c7 e0 08     ret                                                           
4000f19c:   81 e8 00 00     restore                                                       
  if (waiters->count > 0)                                                                 
4000f1a0:   80 a0 60 00     cmp  %g1, 0                                                   
4000f1a4:   22 bf ff d8     be,a   4000f104 <rtems_bdbuf_release+0x50>                    
4000f1a8:   90 17 62 70     or  %i5, 0x270, %o0                                           
  _Condition_Broadcast( condition_variable );                                             
4000f1ac:   40 00 05 d8     call  4001090c <_Condition_Broadcast>                         
4000f1b0:   90 02 20 b8     add  %o0, 0xb8, %o0                                           
}                                                                                         
4000f1b4:   10 bf ff d4     b  4000f104 <rtems_bdbuf_release+0x50>                        
4000f1b8:   90 17 62 70     or  %i5, 0x270, %o0                                           
}                                                                                         
4000f1bc:   81 c7 e0 08     ret                                                           <== NOT EXECUTED
4000f1c0:   91 e8 20 09     restore  %g0, 9, %o0                                          <== NOT EXECUTED
      rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_0);                
4000f1c4:   7f ff f6 cd     call  4000ccf8 <rtems_bdbuf_fatal_with_state>                 <== NOT EXECUTED
4000f1c8:   92 10 20 09     mov  9, %o1                                                   <== NOT EXECUTED
4000f1cc:   01 00 00 00     nop                                                           <== NOT EXECUTED
                                                                                          
===============================================================================
4000f1d0 <rtems_bdbuf_release_modified>:                                                  
{                                                                                         
4000f1d0:   9d e3 bf a0     save  %sp, -96, %sp                                           
  if (bd == NULL)                                                                         
4000f1d4:   80 a6 20 00     cmp  %i0, 0                                                   
4000f1d8:   02 80 00 1e     be  4000f250 <rtems_bdbuf_release_modified+0x80>              <== NEVER TAKEN
4000f1dc:   01 00 00 00     nop                                                           
  _Mutex_Acquire( mutex );                                                                
4000f1e0:   3b 10 00 93     sethi  %hi(0x40024c00), %i5                                   
4000f1e4:   7f ff e9 70     call  400097a4 <_Mutex_Acquire>                               
4000f1e8:   90 17 62 70     or  %i5, 0x270, %o0 ! 40024e70 <bdbuf_cache+0x28>             
  switch (bd->state)                                                                      
4000f1ec:   d0 06 20 20     ld  [ %i0 + 0x20 ], %o0                                       
4000f1f0:   80 a2 20 05     cmp  %o0, 5                                                   
4000f1f4:   08 80 00 0c     bleu  4000f224 <rtems_bdbuf_release_modified+0x54>            
4000f1f8:   80 a2 20 02     cmp  %o0, 2                                                   
4000f1fc:   80 a2 20 06     cmp  %o0, 6                                                   
4000f200:   12 80 00 0b     bne  4000f22c <rtems_bdbuf_release_modified+0x5c>             <== NEVER TAKEN
4000f204:   01 00 00 00     nop                                                           
      rtems_bdbuf_discard_buffer_after_access (bd);                                       
4000f208:   7f ff f7 cb     call  4000d134 <rtems_bdbuf_discard_buffer_after_access>      
4000f20c:   90 10 00 18     mov  %i0, %o0                                                 
  _Mutex_Release( mutex );                                                                
4000f210:   90 17 62 70     or  %i5, 0x270, %o0                                           
4000f214:   7f ff e9 7f     call  40009810 <_Mutex_Release>                               
4000f218:   b0 10 20 00     clr  %i0                                                      
  return RTEMS_SUCCESSFUL;                                                                
4000f21c:   81 c7 e0 08     ret                                                           
4000f220:   81 e8 00 00     restore                                                       
  switch (bd->state)                                                                      
4000f224:   18 80 00 04     bgu  4000f234 <rtems_bdbuf_release_modified+0x64>             <== ALWAYS TAKEN
4000f228:   01 00 00 00     nop                                                           
      rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_6);                
4000f22c:   7f ff f6 b3     call  4000ccf8 <rtems_bdbuf_fatal_with_state>                 
4000f230:   92 10 20 0d     mov  0xd, %o1   ! d <_TLS_Alignment+0xc>                      
      rtems_bdbuf_add_to_modified_list_after_access (bd);                                 
4000f234:   7f ff fe 92     call  4000ec7c <rtems_bdbuf_add_to_modified_list_after_access>
4000f238:   90 10 00 18     mov  %i0, %o0                                                 
4000f23c:   90 17 62 70     or  %i5, 0x270, %o0                                           
4000f240:   7f ff e9 74     call  40009810 <_Mutex_Release>                               
4000f244:   b0 10 20 00     clr  %i0                                                      
  return RTEMS_SUCCESSFUL;                                                                
4000f248:   81 c7 e0 08     ret                                                           
4000f24c:   81 e8 00 00     restore                                                       
}                                                                                         
4000f250:   81 c7 e0 08     ret                                                           <== NOT EXECUTED
4000f254:   91 e8 20 09     restore  %g0, 9, %o0                                          <== NOT EXECUTED
                                                                                          
===============================================================================
4000f4c8 <rtems_bdbuf_set_block_size>:                                                    
{                                                                                         
4000f4c8:   9d e3 bf a0     save  %sp, -96, %sp                                           
  if (sync)                                                                               
4000f4cc:   80 a6 a0 00     cmp  %i2, 0                                                   
4000f4d0:   12 80 00 4d     bne  4000f604 <rtems_bdbuf_set_block_size+0x13c>              
4000f4d4:   ba 10 00 18     mov  %i0, %i5                                                 
  _Mutex_Acquire( mutex );                                                                
4000f4d8:   39 10 00 93     sethi  %hi(0x40024c00), %i4                                   
4000f4dc:   7f ff e8 b2     call  400097a4 <_Mutex_Acquire>                               
4000f4e0:   90 17 22 70     or  %i4, 0x270, %o0 ! 40024e70 <bdbuf_cache+0x28>             
  if (block_size > 0)                                                                     
4000f4e4:   80 a6 60 00     cmp  %i1, 0                                                   
4000f4e8:   12 80 00 06     bne  4000f500 <rtems_bdbuf_set_block_size+0x38>               
4000f4ec:   b0 10 20 0a     mov  0xa, %i0                                                 
  _Mutex_Release( mutex );                                                                
4000f4f0:   7f ff e8 c8     call  40009810 <_Mutex_Release>                               
4000f4f4:   90 17 22 70     or  %i4, 0x270, %o0                                           
}                                                                                         
4000f4f8:   81 c7 e0 08     ret                                                           
4000f4fc:   81 e8 00 00     restore                                                       
  if (size > bdbuf_config.buffer_max)                                                     
4000f500:   03 10 00 7c     sethi  %hi(0x4001f000), %g1                                   
4000f504:   82 10 63 dc     or  %g1, 0x3dc, %g1 ! 4001f3dc <rtems_bdbuf_configuration>    
4000f508:   c4 00 60 28     ld  [ %g1 + 0x28 ], %g2                                       
4000f50c:   80 a6 40 02     cmp  %i1, %g2                                                 
4000f510:   18 bf ff f8     bgu  4000f4f0 <rtems_bdbuf_set_block_size+0x28>               
4000f514:   84 06 7f ff     add  %i1, -1, %g2                                             
  bufs_per_size = ((size - 1) / bdbuf_config.buffer_min) + 1;                             
4000f518:   81 80 20 00     wr  %g0, %y                                                   
4000f51c:   c6 00 60 24     ld  [ %g1 + 0x24 ], %g3                                       
4000f520:   01 00 00 00     nop                                                           
4000f524:   01 00 00 00     nop                                                           
4000f528:   86 70 80 03     udiv  %g2, %g3, %g3                                           
  for (bds_per_size = 1;                                                                  
4000f52c:   82 10 20 01     mov  1, %g1                                                   
4000f530:   80 a0 e0 00     cmp  %g3, 0                                                   
4000f534:   02 80 00 06     be  4000f54c <rtems_bdbuf_set_block_size+0x84>                
4000f538:   84 00 e0 01     add  %g3, 1, %g2                                              
       bds_per_size <<= 1)                                                                
4000f53c:   83 28 60 01     sll  %g1, 1, %g1                                              
  for (bds_per_size = 1;                                                                  
4000f540:   80 a0 80 01     cmp  %g2, %g1                                                 
4000f544:   38 bf ff ff     bgu,a   4000f540 <rtems_bdbuf_set_block_size+0x78>            
4000f548:   83 28 60 01     sll  %g1, 1, %g1                                              
  return bdbuf_cache.max_bds_per_group / bds_per_size;                                    
4000f54c:   05 10 00 93     sethi  %hi(0x40024c00), %g2                                   
4000f550:   c4 00 a2 68     ld  [ %g2 + 0x268 ], %g2    ! 40024e68 <bdbuf_cache+0x20>     
4000f554:   81 80 20 00     wr  %g0, %y                                                   
4000f558:   01 00 00 00     nop                                                           
4000f55c:   01 00 00 00     nop                                                           
4000f560:   01 00 00 00     nop                                                           
4000f564:   b4 70 80 01     udiv  %g2, %g1, %i2                                           
    if (bds_per_group != 0)                                                               
4000f568:   80 a0 80 01     cmp  %g2, %g1                                                 
4000f56c:   2a bf ff e1     bcs,a   4000f4f0 <rtems_bdbuf_set_block_size+0x28>            <== NEVER TAKEN
4000f570:   b0 10 20 0a     mov  0xa, %i0                                                 <== NOT EXECUTED
      uint32_t media_blocks_per_block = block_size / dd->media_block_size;                
4000f574:   f6 07 60 20     ld  [ %i5 + 0x20 ], %i3                                       
4000f578:   81 80 20 00     wr  %g0, %y                                                   
4000f57c:   01 00 00 00     nop                                                           
4000f580:   01 00 00 00     nop                                                           
4000f584:   01 00 00 00     nop                                                           
4000f588:   86 76 40 1b     udiv  %i1, %i3, %g3                                           
      while ((one << block_to_media_block_shift) < media_blocks_per_block)                
4000f58c:   80 a0 e0 01     cmp  %g3, 1                                                   
4000f590:   08 80 00 09     bleu  4000f5b4 <rtems_bdbuf_set_block_size+0xec>              
4000f594:   82 10 20 00     clr  %g1                                                      
4000f598:   88 10 20 01     mov  1, %g4                                                   
        ++block_to_media_block_shift;                                                     
4000f59c:   82 00 60 01     inc  %g1                                                      
      while ((one << block_to_media_block_shift) < media_blocks_per_block)                
4000f5a0:   85 29 00 01     sll  %g4, %g1, %g2                                            
4000f5a4:   80 a0 80 03     cmp  %g2, %g3                                                 
4000f5a8:   2a bf ff fe     bcs,a   4000f5a0 <rtems_bdbuf_set_block_size+0xd8>            
4000f5ac:   82 00 60 01     inc  %g1                                                      
      if ((dd->media_block_size << block_to_media_block_shift) != block_size)             
4000f5b0:   b7 2e c0 01     sll  %i3, %g1, %i3                                            
4000f5b4:   80 a6 40 1b     cmp  %i1, %i3                                                 
4000f5b8:   32 80 00 02     bne,a   4000f5c0 <rtems_bdbuf_set_block_size+0xf8>            <== NEVER TAKEN
4000f5bc:   82 10 3f ff     mov  -1, %g1                                                  <== NOT EXECUTED
      dd->block_count = dd->size / media_blocks_per_block;                                
4000f5c0:   81 80 20 00     wr  %g0, %y                                                   
4000f5c4:   c4 07 60 1c     ld  [ %i5 + 0x1c ], %g2                                       
4000f5c8:   01 00 00 00     nop                                                           
4000f5cc:   01 00 00 00     nop                                                           
4000f5d0:   84 70 80 03     udiv  %g2, %g3, %g2                                           
      dd->block_size = block_size;                                                        
4000f5d4:   f2 27 60 24     st  %i1, [ %i5 + 0x24 ]                                       
      rtems_bdbuf_do_purge_dev (dd);                                                      
4000f5d8:   90 10 00 1d     mov  %i5, %o0                                                 
      dd->block_count = dd->size / media_blocks_per_block;                                
4000f5dc:   c4 27 60 28     st  %g2, [ %i5 + 0x28 ]                                       
  rtems_status_code sc = RTEMS_SUCCESSFUL;                                                
4000f5e0:   b0 10 20 00     clr  %i0                                                      
      dd->media_blocks_per_block = media_blocks_per_block;                                
4000f5e4:   c6 27 60 2c     st  %g3, [ %i5 + 0x2c ]                                       
      dd->block_to_media_block_shift = block_to_media_block_shift;                        
4000f5e8:   c2 27 60 30     st  %g1, [ %i5 + 0x30 ]                                       
      rtems_bdbuf_do_purge_dev (dd);                                                      
4000f5ec:   7f ff f7 0c     call  4000d21c <rtems_bdbuf_do_purge_dev>                     
4000f5f0:   f4 27 60 34     st  %i2, [ %i5 + 0x34 ]                                       
4000f5f4:   7f ff e8 87     call  40009810 <_Mutex_Release>                               
4000f5f8:   90 17 22 70     or  %i4, 0x270, %o0                                           
}                                                                                         
4000f5fc:   81 c7 e0 08     ret                                                           
4000f600:   81 e8 00 00     restore                                                       
    rtems_bdbuf_syncdev (dd);                                                             
4000f604:   7f ff ff 7f     call  4000f400 <rtems_bdbuf_syncdev>                          
4000f608:   90 10 00 18     mov  %i0, %o0                                                 
  _Mutex_Acquire( mutex );                                                                
4000f60c:   10 bf ff b4     b  4000f4dc <rtems_bdbuf_set_block_size+0x14>                 
4000f610:   39 10 00 93     sethi  %hi(0x40024c00), %i4                                   
                                                                                          
===============================================================================
4000f258 <rtems_bdbuf_sync>:                                                              
{                                                                                         
4000f258:   9d e3 bf a0     save  %sp, -96, %sp                                           
  if (bd == NULL)                                                                         
4000f25c:   80 a6 20 00     cmp  %i0, 0                                                   
4000f260:   02 80 00 54     be  4000f3b0 <rtems_bdbuf_sync+0x158>                         <== NEVER TAKEN
4000f264:   01 00 00 00     nop                                                           
  _Mutex_Acquire( mutex );                                                                
4000f268:   3b 10 00 93     sethi  %hi(0x40024c00), %i5                                   
4000f26c:   7f ff e9 4e     call  400097a4 <_Mutex_Acquire>                               
4000f270:   90 17 62 70     or  %i5, 0x270, %o0 ! 40024e70 <bdbuf_cache+0x28>             
  switch (bd->state)                                                                      
4000f274:   d0 06 20 20     ld  [ %i0 + 0x20 ], %o0                                       
4000f278:   80 a2 20 05     cmp  %o0, 5                                                   
4000f27c:   08 80 00 0c     bleu  4000f2ac <rtems_bdbuf_sync+0x54>                        
4000f280:   80 a2 20 02     cmp  %o0, 2                                                   
4000f284:   80 a2 20 06     cmp  %o0, 6                                                   
4000f288:   12 80 00 0b     bne  4000f2b4 <rtems_bdbuf_sync+0x5c>                         <== NEVER TAKEN
4000f28c:   01 00 00 00     nop                                                           
      rtems_bdbuf_discard_buffer_after_access (bd);                                       
4000f290:   7f ff f7 a9     call  4000d134 <rtems_bdbuf_discard_buffer_after_access>      
4000f294:   90 10 00 18     mov  %i0, %o0                                                 
  _Mutex_Release( mutex );                                                                
4000f298:   90 17 62 70     or  %i5, 0x270, %o0                                           
4000f29c:   7f ff e9 5d     call  40009810 <_Mutex_Release>                               
4000f2a0:   b0 10 20 00     clr  %i0                                                      
  return RTEMS_SUCCESSFUL;                                                                
4000f2a4:   81 c7 e0 08     ret                                                           
4000f2a8:   81 e8 00 00     restore                                                       
  switch (bd->state)                                                                      
4000f2ac:   18 80 00 04     bgu  4000f2bc <rtems_bdbuf_sync+0x64>                         <== ALWAYS TAKEN
4000f2b0:   82 10 20 08     mov  8, %g1                                                   
      rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_5);                
4000f2b4:   7f ff f6 91     call  4000ccf8 <rtems_bdbuf_fatal_with_state>                 <== NOT EXECUTED
4000f2b8:   92 10 20 0c     mov  0xc, %o1                                                 <== NOT EXECUTED
  old_last = tail->previous;                                                              
4000f2bc:   37 10 00 93     sethi  %hi(0x40024c00), %i3                                   
  bd->state = state;                                                                      
4000f2c0:   c2 26 20 20     st  %g1, [ %i0 + 0x20 ]                                       
4000f2c4:   b8 16 e2 48     or  %i3, 0x248, %i4                                           
4000f2c8:   c2 07 20 80     ld  [ %i4 + 0x80 ], %g1                                       
  the_node->next = tail;                                                                  
4000f2cc:   84 07 20 7c     add  %i4, 0x7c, %g2                                           
4000f2d0:   c4 26 00 00     st  %g2, [ %i0 ]                                              
  tail->previous = the_node;                                                              
4000f2d4:   f0 27 20 80     st  %i0, [ %i4 + 0x80 ]                                       
  old_last->next = the_node;                                                              
4000f2d8:   f0 20 40 00     st  %i0, [ %g1 ]                                              
  the_node->previous = old_last;                                                          
4000f2dc:   c2 26 20 04     st  %g1, [ %i0 + 4 ]                                          
  if (bd->waiters)                                                                        
4000f2e0:   c2 06 20 24     ld  [ %i0 + 0x24 ], %g1                                       
4000f2e4:   80 a0 60 00     cmp  %g1, 0                                                   
4000f2e8:   02 80 00 06     be  4000f300 <rtems_bdbuf_sync+0xa8>                          
4000f2ec:   d0 06 e2 48     ld  [ %i3 + 0x248 ], %o0                                      
  if (waiters->count > 0)                                                                 
4000f2f0:   c2 07 20 84     ld  [ %i4 + 0x84 ], %g1                                       
4000f2f4:   80 a0 60 00     cmp  %g1, 0                                                   
4000f2f8:   12 80 00 2a     bne  4000f3a0 <rtems_bdbuf_sync+0x148>                        
4000f2fc:   01 00 00 00     nop                                                           
  rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,                           
4000f300:   92 10 20 04     mov  4, %o1 ! 4 <_TLS_Alignment+0x3>                          
4000f304:   40 00 04 83     call  40010510 <rtems_event_send>                             
4000f308:   37 10 00 93     sethi  %hi(0x40024c00), %i3                                   
  if (sc != RTEMS_SUCCESSFUL)                                                             
4000f30c:   80 a2 20 00     cmp  %o0, 0                                                   
4000f310:   12 80 00 37     bne  4000f3ec <rtems_bdbuf_sync+0x194>                        <== NEVER TAKEN
4000f314:   b6 16 e2 e4     or  %i3, 0x2e4, %i3                                           
    switch (bd->state)                                                                    
4000f318:   d0 06 20 20     ld  [ %i0 + 0x20 ], %o0                                       
4000f31c:   80 a2 20 07     cmp  %o0, 7                                                   
4000f320:   18 80 00 07     bgu  4000f33c <rtems_bdbuf_sync+0xe4>                         
4000f324:   82 02 3f f8     add  %o0, -8, %g1                                             
4000f328:   80 a2 20 00     cmp  %o0, 0                                                   
4000f32c:   32 80 00 0b     bne,a   4000f358 <rtems_bdbuf_sync+0x100>                     <== ALWAYS TAKEN
4000f330:   c2 06 20 24     ld  [ %i0 + 0x24 ], %g1                                       
        rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_9);              
4000f334:   7f ff f6 71     call  4000ccf8 <rtems_bdbuf_fatal_with_state>                 <== NOT EXECUTED
4000f338:   92 10 20 10     mov  0x10, %o1                                                <== NOT EXECUTED
    switch (bd->state)                                                                    
4000f33c:   80 a0 60 02     cmp  %g1, 2                                                   
4000f340:   18 bf ff fd     bgu  4000f334 <rtems_bdbuf_sync+0xdc>                         <== NEVER TAKEN
4000f344:   92 10 00 1b     mov  %i3, %o1                                                 
        rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);                             
4000f348:   7f ff f7 60     call  4000d0c8 <rtems_bdbuf_wait>                             
4000f34c:   90 10 00 18     mov  %i0, %o0                                                 
        break;                                                                            
4000f350:   10 bf ff f3     b  4000f31c <rtems_bdbuf_sync+0xc4>                           
4000f354:   d0 06 20 20     ld  [ %i0 + 0x20 ], %o0                                       
  if (bd->waiters == 0                                                                    
4000f358:   80 a0 60 00     cmp  %g1, 0                                                   
4000f35c:   32 bf ff d0     bne,a   4000f29c <rtems_bdbuf_sync+0x44>                      
4000f360:   90 17 62 70     or  %i5, 0x270, %o0                                           
          || bd->state == RTEMS_BDBUF_STATE_EMPTY))                                       
4000f364:   82 02 3f ff     add  %o0, -1, %g1                                             
        && (bd->state == RTEMS_BDBUF_STATE_CACHED                                         
4000f368:   80 a0 60 01     cmp  %g1, 1                                                   
4000f36c:   38 bf ff cc     bgu,a   4000f29c <rtems_bdbuf_sync+0x44>                      <== NEVER TAKEN
4000f370:   90 17 62 70     or  %i5, 0x270, %o0                                           <== NOT EXECUTED
    if (bd->state == RTEMS_BDBUF_STATE_EMPTY)                                             
4000f374:   80 a2 20 01     cmp  %o0, 1                                                   
4000f378:   22 80 00 10     be,a   4000f3b8 <rtems_bdbuf_sync+0x160>                      
4000f37c:   d2 06 20 18     ld  [ %i0 + 0x18 ], %o1                                       
  if (waiters->count > 0)                                                                 
4000f380:   c2 07 20 b4     ld  [ %i4 + 0xb4 ], %g1                                       
4000f384:   80 a0 60 00     cmp  %g1, 0                                                   
4000f388:   22 bf ff c5     be,a   4000f29c <rtems_bdbuf_sync+0x44>                       
4000f38c:   90 17 62 70     or  %i5, 0x270, %o0                                           
  _Condition_Broadcast( condition_variable );                                             
4000f390:   40 00 05 5f     call  4001090c <_Condition_Broadcast>                         
4000f394:   90 07 20 b8     add  %i4, 0xb8, %o0                                           
}                                                                                         
4000f398:   10 bf ff c1     b  4000f29c <rtems_bdbuf_sync+0x44>                           
4000f39c:   90 17 62 70     or  %i5, 0x270, %o0                                           
  _Condition_Broadcast( condition_variable );                                             
4000f3a0:   40 00 05 5b     call  4001090c <_Condition_Broadcast>                         
4000f3a4:   90 07 20 88     add  %i4, 0x88, %o0                                           
}                                                                                         
4000f3a8:   10 bf ff d6     b  4000f300 <rtems_bdbuf_sync+0xa8>                           
4000f3ac:   d0 06 e2 48     ld  [ %i3 + 0x248 ], %o0                                      
}                                                                                         
4000f3b0:   81 c7 e0 08     ret                                                           <== NOT EXECUTED
4000f3b4:   91 e8 20 09     restore  %g0, 9, %o0                                          <== NOT EXECUTED
  if (rtems_bdbuf_avl_remove (&bdbuf_cache.tree, bd) != 0)                                
4000f3b8:   7f ff f6 5b     call  4000cd24 <rtems_bdbuf_avl_remove.constprop.0.isra.0>    
4000f3bc:   d0 06 20 14     ld  [ %i0 + 0x14 ], %o0                                       
4000f3c0:   80 a2 20 00     cmp  %o0, 0                                                   
4000f3c4:   12 80 00 0c     bne  4000f3f4 <rtems_bdbuf_sync+0x19c>                        <== NEVER TAKEN
4000f3c8:   03 10 00 93     sethi  %hi(0x40024c00), %g1                                   
  bd->state = state;                                                                      
4000f3cc:   c0 26 20 20     clr  [ %i0 + 0x20 ]                                           
  the_node->previous    = after_node;                                                     
4000f3d0:   82 10 62 a8     or  %g1, 0x2a8, %g1                                           
4000f3d4:   c2 26 20 04     st  %g1, [ %i0 + 4 ]                                          
  before_node           = after_node->next;                                               
4000f3d8:   c2 07 20 60     ld  [ %i4 + 0x60 ], %g1                                       
  after_node->next      = the_node;                                                       
4000f3dc:   f0 27 20 60     st  %i0, [ %i4 + 0x60 ]                                       
  the_node->next        = before_node;                                                    
4000f3e0:   c2 26 00 00     st  %g1, [ %i0 ]                                              
}                                                                                         
4000f3e4:   10 bf ff e7     b  4000f380 <rtems_bdbuf_sync+0x128>                          
4000f3e8:   f0 20 60 04     st  %i0, [ %g1 + 4 ]                                          
    rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WAKE_1);                                      
4000f3ec:   7f ff f6 3e     call  4000cce4 <rtems_bdbuf_fatal>                            <== NOT EXECUTED
4000f3f0:   90 10 20 07     mov  7, %o0                                                   <== NOT EXECUTED
4000f3f4:   7f ff f7 30     call  4000d0b4 <rtems_bdbuf_remove_from_tree.part.0.isra.0>   <== NOT EXECUTED
4000f3f8:   d0 06 20 20     ld  [ %i0 + 0x20 ], %o0                                       <== NOT EXECUTED
4000f3fc:   01 00 00 00     nop                                                           <== NOT EXECUTED
                                                                                          
===============================================================================
4000f400 <rtems_bdbuf_syncdev>:                                                           
{                                                                                         
4000f400:   9d e3 bf 98     save  %sp, -104, %sp                                          
  _Mutex_Acquire( mutex );                                                                
4000f404:   37 10 00 93     sethi  %hi(0x40024c00), %i3                                   
4000f408:   7f ff e8 e7     call  400097a4 <_Mutex_Acquire>                               
4000f40c:   90 16 e2 84     or  %i3, 0x284, %o0 ! 40024e84 <bdbuf_cache+0x3c>             
4000f410:   35 10 00 93     sethi  %hi(0x40024c00), %i2                                   
4000f414:   7f ff e8 e4     call  400097a4 <_Mutex_Acquire>                               
4000f418:   90 16 a2 70     or  %i2, 0x270, %o0 ! 40024e70 <bdbuf_cache+0x28>             
  bdbuf_cache.sync_active    = true;                                                      
4000f41c:   82 10 20 01     mov  1, %g1                                                   
4000f420:   39 10 00 93     sethi  %hi(0x40024c00), %i4                                   
4000f424:   ba 17 22 48     or  %i4, 0x248, %i5 ! 40024e48 <bdbuf_cache>                  
  bdbuf_cache.sync_requester = rtems_task_self ();                                        
4000f428:   40 00 04 f9     call  4001080c <rtems_task_self>                              
4000f42c:   c2 2f 60 50     stb  %g1, [ %i5 + 0x50 ]                                      
4000f430:   82 10 00 08     mov  %o0, %g1                                                 
  rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,                           
4000f434:   d0 07 22 48     ld  [ %i4 + 0x248 ], %o0                                      
  bdbuf_cache.sync_requester = rtems_task_self ();                                        
4000f438:   c2 27 60 54     st  %g1, [ %i5 + 0x54 ]                                       
  rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,                           
4000f43c:   92 10 20 04     mov  4, %o1                                                   
4000f440:   40 00 04 34     call  40010510 <rtems_event_send>                             
4000f444:   f0 27 60 58     st  %i0, [ %i5 + 0x58 ]                                       
  if (sc != RTEMS_SUCCESSFUL)                                                             
4000f448:   80 a2 20 00     cmp  %o0, 0                                                   
4000f44c:   12 80 00 10     bne  4000f48c <rtems_bdbuf_syncdev+0x8c>                      <== NEVER TAKEN
4000f450:   01 00 00 00     nop                                                           
  _Mutex_Release( mutex );                                                                
4000f454:   7f ff e8 ef     call  40009810 <_Mutex_Release>                               
4000f458:   90 16 a2 70     or  %i2, 0x270, %o0                                           
  return rtems_event_system_receive(                                                      
4000f45c:   96 07 bf fc     add  %fp, -4, %o3                                             
4000f460:   94 10 20 00     clr  %o2                                                      
4000f464:   92 10 20 00     clr  %o1                                                      
4000f468:   40 00 04 73     call  40010634 <rtems_event_system_receive>                   
4000f46c:   11 20 00 00     sethi  %hi(0x80000000), %o0                                   
  if (sc != RTEMS_SUCCESSFUL)                                                             
4000f470:   80 a2 20 00     cmp  %o0, 0                                                   
4000f474:   12 80 00 08     bne  4000f494 <rtems_bdbuf_syncdev+0x94>                      <== NEVER TAKEN
4000f478:   b0 10 20 00     clr  %i0                                                      
4000f47c:   7f ff e8 e5     call  40009810 <_Mutex_Release>                               
4000f480:   90 16 e2 84     or  %i3, 0x284, %o0                                           
}                                                                                         
4000f484:   81 c7 e0 08     ret                                                           
4000f488:   81 e8 00 00     restore                                                       
    rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WAKE_1);                                      
4000f48c:   7f ff f6 16     call  4000cce4 <rtems_bdbuf_fatal>                            <== NOT EXECUTED
4000f490:   90 10 20 07     mov  7, %o0                                                   <== NOT EXECUTED
    rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_WAIT_TRANS_EVNT);                                
4000f494:   7f ff f6 14     call  4000cce4 <rtems_bdbuf_fatal>                            <== NOT EXECUTED
4000f498:   90 10 20 16     mov  0x16, %o0                                                <== NOT EXECUTED
4000f49c:   01 00 00 00     nop                                                           <== NOT EXECUTED
                                                                                          
===============================================================================
40001768 <rtems_bdpart_create>:                                                           
  const rtems_bdpart_format *format,                                                      
  rtems_bdpart_partition *pt,                                                             
  const unsigned *dist,                                                                   
  size_t count                                                                            
)                                                                                         
{                                                                                         
40001768:   9d e3 bf 98     save  %sp, -104, %sp                                          
  rtems_status_code sc = RTEMS_SUCCESSFUL;                                                
  bool dos_compatibility = format != NULL                                                 
    && format->type == RTEMS_BDPART_FORMAT_MBR                                            
    && format->mbr.dos_compatibility;                                                     
4000176c:   80 a6 60 00     cmp  %i1, 0                                                   
40001770:   02 80 00 07     be  4000178c <rtems_bdpart_create+0x24>                       <== NEVER TAKEN
40001774:   a2 10 20 00     clr  %l1                                                      
    && format->type == RTEMS_BDPART_FORMAT_MBR                                            
40001778:   c2 06 40 00     ld  [ %i1 ], %g1                                              
4000177c:   80 a0 60 00     cmp  %g1, 0                                                   
40001780:   22 80 00 6d     be,a   40001934 <rtems_bdpart_create+0x1cc>                   <== ALWAYS TAKEN
40001784:   c2 0e 60 08     ldub  [ %i1 + 8 ], %g1                                        
    && format->mbr.dos_compatibility;                                                     
40001788:   a2 10 20 00     clr  %l1                                                      <== NOT EXECUTED
  rtems_blkdev_bnum disk_end = 0;                                                         
  rtems_blkdev_bnum pos = 0;                                                              
  rtems_blkdev_bnum dist_sum = 0;                                                         
  rtems_blkdev_bnum record_space =                                                        
    dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;                               
4000178c:   a0 10 20 01     mov  1, %l0                                                   <== NOT EXECUTED
40001790:   c0 27 bf fc     clr  [ %fp + -4 ]                                             
  rtems_blkdev_bnum overhead = 0;                                                         
  rtems_blkdev_bnum free_space = 0;                                                       
  size_t i = 0;                                                                           
                                                                                          
  /* Check if we have something to do */                                                  
  if (count == 0) {                                                                       
40001794:   80 a7 20 00     cmp  %i4, 0                                                   
40001798:   02 80 00 65     be  4000192c <rtems_bdpart_create+0x1c4>                      <== NEVER TAKEN
4000179c:   90 10 20 00     clr  %o0                                                      
    /* Nothing to do */                                                                   
    return RTEMS_SUCCESSFUL;                                                              
  }                                                                                       
                                                                                          
  /* Check parameter */                                                                   
  if (format == NULL || pt == NULL || dist == NULL) {                                     
400017a0:   80 a0 00 1a     cmp  %g0, %i2                                                 
400017a4:   84 60 3f ff     subx  %g0, -1, %g2                                            
400017a8:   80 a0 00 1b     cmp  %g0, %i3                                                 
400017ac:   82 60 3f ff     subx  %g0, -1, %g1                                            
400017b0:   80 90 80 01     orcc  %g2, %g1, %g0                                           
400017b4:   12 80 00 66     bne  4000194c <rtems_bdpart_create+0x1e4>                     <== NEVER TAKEN
400017b8:   80 a6 60 00     cmp  %i1, 0                                                   
400017bc:   02 80 00 64     be  4000194c <rtems_bdpart_create+0x1e4>                      <== NEVER TAKEN
400017c0:   96 07 bf fc     add  %fp, -4, %o3                                             
    return RTEMS_INVALID_ADDRESS;                                                         
  }                                                                                       
                                                                                          
  /* Get disk data */                                                                     
  sc = rtems_bdpart_get_disk_data( disk_name, NULL, NULL, &disk_end);                     
400017c4:   94 10 20 00     clr  %o2                                                      
400017c8:   92 10 20 00     clr  %o1                                                      
400017cc:   40 00 01 48     call  40001cec <rtems_bdpart_get_disk_data>                   
400017d0:   90 10 00 18     mov  %i0, %o0                                                 
  if (sc != RTEMS_SUCCESSFUL) {                                                           
400017d4:   80 a2 20 00     cmp  %o0, 0                                                   
400017d8:   02 80 00 04     be  400017e8 <rtems_bdpart_create+0x80>                       <== ALWAYS TAKEN
400017dc:   86 10 20 00     clr  %g3                                                      
                                                                                          
  /* Expand the last partition to the disk end */                                         
  pt [count - 1].end = disk_end;                                                          
                                                                                          
  return RTEMS_SUCCESSFUL;                                                                
}                                                                                         
400017e0:   81 c7 e0 08     ret                                                           <== NOT EXECUTED
400017e4:   91 e8 00 08     restore  %g0, %o0, %o0                                        <== NOT EXECUTED
    dist_sum += dist [i];                                                                 
400017e8:   83 28 e0 02     sll  %g3, 2, %g1                                              
400017ec:   c2 06 c0 01     ld  [ %i3 + %g1 ], %g1                                        
400017f0:   88 80 40 08     addcc  %g1, %o0, %g4                                          
400017f4:   ba 40 20 00     addx  %g0, 0, %i5                                             
    if (dist [i] == 0) {                                                                  
400017f8:   80 a0 60 00     cmp  %g1, 0                                                   
400017fc:   02 80 00 4b     be  40001928 <rtems_bdpart_create+0x1c0>                      <== NEVER TAKEN
40001800:   90 10 00 04     mov  %g4, %o0                                                 
40001804:   80 a7 60 00     cmp  %i5, 0                                                   
40001808:   32 80 00 49     bne,a   4000192c <rtems_bdpart_create+0x1c4>                  <== NEVER TAKEN
4000180c:   90 10 20 0a     mov  0xa, %o0                                                 <== NOT EXECUTED
  for (i = 0; i < count; ++i) {                                                           
40001810:   82 00 e0 01     add  %g3, 1, %g1                                              
40001814:   80 a7 00 01     cmp  %i4, %g1                                                 
40001818:   32 bf ff f4     bne,a   400017e8 <rtems_bdpart_create+0x80>                   
4000181c:   86 10 00 01     mov  %g1, %g3                                                 
  if (format->type != RTEMS_BDPART_FORMAT_MBR) {                                          
40001820:   fa 06 40 00     ld  [ %i1 ], %i5                                              
40001824:   80 a7 60 00     cmp  %i5, 0                                                   
40001828:   12 80 00 41     bne  4000192c <rtems_bdpart_create+0x1c4>                     <== NEVER TAKEN
4000182c:   90 10 20 18     mov  0x18, %o0                                                
  if (dos_compatibility) {                                                                
40001830:   80 a4 60 00     cmp  %l1, 0                                                   
40001834:   12 80 00 4a     bne  4000195c <rtems_bdpart_create+0x1f4>                     <== ALWAYS TAKEN
40001838:   da 07 bf fc     ld  [ %fp + -4 ], %o5                                         
  if (count > 4) {                                                                        
4000183c:   80 a0 60 04     cmp  %g1, 4                                                   <== NOT EXECUTED
40001840:   08 80 00 04     bleu  40001850 <rtems_bdpart_create+0xe8>                     <== NOT EXECUTED
40001844:   9e 10 00 10     mov  %l0, %o7                                                 <== NOT EXECUTED
    overhead += (count - 3) * record_space;                                               
40001848:   9e 00 ff ff     add  %g3, -1, %o7                                             <== NOT EXECUTED
4000184c:   9e 5b c0 10     smul  %o7, %l0, %o7                                           <== NOT EXECUTED
  if ((overhead + count) > disk_end) {                                                    
40001850:   ba 03 c0 01     add  %o7, %g1, %i5                                            
40001854:   80 a7 40 0d     cmp  %i5, %o5                                                 
40001858:   18 80 00 35     bgu  4000192c <rtems_bdpart_create+0x1c4>                     <== NEVER TAKEN
4000185c:   90 10 20 1b     mov  0x1b, %o0                                                
  free_space = disk_end - overhead;                                                       
40001860:   9e 23 40 0f     sub  %o5, %o7, %o7                                            
  for (i = 0; i < count; ++i) {                                                           
40001864:   b0 10 00 1a     mov  %i2, %i0                                                 
40001868:   b2 10 20 00     clr  %i1                                                      
  pos = record_space;                                                                     
4000186c:   10 80 00 25     b  40001900 <rtems_bdpart_create+0x198>                       
40001870:   b8 10 00 10     mov  %l0, %i4                                                 
    if (s == 0) {                                                                         
40001874:   0a 80 00 07     bcs  40001890 <rtems_bdpart_create+0x128>                     <== NEVER TAKEN
40001878:   84 10 20 01     mov  1, %g2                                                   
    s /= dist_sum;                                                                        
4000187c:   81 80 20 00     wr  %g0, %y                                                   
40001880:   01 00 00 00     nop                                                           
40001884:   01 00 00 00     nop                                                           
40001888:   01 00 00 00     nop                                                           
4000188c:   84 77 40 04     udiv  %i5, %g4, %g2                                           
    s += record_space - (s % record_space);                                               
40001890:   81 80 20 00     wr  %g0, %y                                                   
40001894:   01 00 00 00     nop                                                           
40001898:   01 00 00 00     nop                                                           
4000189c:   01 00 00 00     nop                                                           
400018a0:   84 70 80 10     udiv  %g2, %l0, %g2                                           
    if (count > 4 && i > 2) {                                                             
400018a4:   ba 10 20 01     mov  1, %i5                                                   
    s += record_space - (s % record_space);                                               
400018a8:   84 58 80 10     smul  %g2, %l0, %g2                                           
    if (count > 4 && i > 2) {                                                             
400018ac:   80 a0 60 04     cmp  %g1, 4                                                   
400018b0:   18 80 00 03     bgu  400018bc <rtems_bdpart_create+0x154>                     <== ALWAYS TAKEN
400018b4:   84 04 00 02     add  %l0, %g2, %g2                                            
400018b8:   ba 10 20 00     clr  %i5                                                      <== NOT EXECUTED
400018bc:   80 8f 60 ff     btst  0xff, %i5                                               
400018c0:   02 80 00 08     be  400018e0 <rtems_bdpart_create+0x178>                      <== NEVER TAKEN
400018c4:   80 a6 60 02     cmp  %i1, 2                                                   
400018c8:   18 80 00 03     bgu  400018d4 <rtems_bdpart_create+0x16c>                     
400018cc:   ba 10 20 01     mov  1, %i5                                                   
400018d0:   ba 10 20 00     clr  %i5                                                      
400018d4:   80 8f 60 ff     btst  0xff, %i5                                               
400018d8:   32 80 00 02     bne,a   400018e0 <rtems_bdpart_create+0x178>                  
400018dc:   b8 07 00 10     add  %i4, %l0, %i4                                            
    p->begin = pos;                                                                       
400018e0:   f8 26 00 00     st  %i4, [ %i0 ]                                              
    pos += s;                                                                             
400018e4:   b8 07 00 02     add  %i4, %g2, %i4                                            
    p->end = pos;                                                                         
400018e8:   f8 26 20 04     st  %i4, [ %i0 + 4 ]                                          
  for (i = 0; i < count; ++i) {                                                           
400018ec:   84 06 60 01     add  %i1, 1, %g2                                              
400018f0:   80 a0 c0 19     cmp  %g3, %i1                                                 
400018f4:   02 80 00 26     be  4000198c <rtems_bdpart_create+0x224>                      
400018f8:   b0 06 20 30     add  %i0, 0x30, %i0                                           
400018fc:   b2 10 00 02     mov  %g2, %i1                                                 
    rtems_blkdev_bnum s = free_space * dist [i];                                          
40001900:   85 2e 60 02     sll  %i1, 2, %g2                                              
40001904:   fa 06 c0 02     ld  [ %i3 + %g2 ], %i5                                        
    if (s < free_space || s < dist [i]) {                                                 
40001908:   84 10 00 1d     mov  %i5, %g2                                                 
4000190c:   80 a0 80 0f     cmp  %g2, %o7                                                 
40001910:   1a 80 00 03     bcc  4000191c <rtems_bdpart_create+0x1b4>                     <== NEVER TAKEN
40001914:   ba 5f 40 0f     smul  %i5, %o7, %i5                                           
40001918:   84 10 00 0f     mov  %o7, %g2                                                 
4000191c:   80 a7 40 02     cmp  %i5, %g2                                                 
40001920:   1a bf ff d5     bcc  40001874 <rtems_bdpart_create+0x10c>                     <== ALWAYS TAKEN
40001924:   80 a7 40 04     cmp  %i5, %g4                                                 
      return RTEMS_INVALID_NUMBER;                                                        
40001928:   90 10 20 0a     mov  0xa, %o0                                                 <== NOT EXECUTED
}                                                                                         
4000192c:   81 c7 e0 08     ret                                                           
40001930:   91 e8 00 08     restore  %g0, %o0, %o0                                        
    && format->mbr.dos_compatibility;                                                     
40001934:   80 a0 60 00     cmp  %g1, 0                                                   
40001938:   22 bf ff 95     be,a   4000178c <rtems_bdpart_create+0x24>                    <== NEVER TAKEN
4000193c:   a2 10 20 00     clr  %l1                                                      <== NOT EXECUTED
40001940:   a2 10 20 01     mov  1, %l1                                                   
    dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;                               
40001944:   10 bf ff 93     b  40001790 <rtems_bdpart_create+0x28>                        
40001948:   a0 10 20 3f     mov  0x3f, %l0                                                
    return RTEMS_INVALID_ADDRESS;                                                         
4000194c:   90 10 20 09     mov  9, %o0                                                   <== NOT EXECUTED
}                                                                                         
40001950:   b0 10 00 08     mov  %o0, %i0                                                 <== NOT EXECUTED
40001954:   81 c7 e0 08     ret                                                           <== NOT EXECUTED
40001958:   81 e8 00 00     restore                                                       <== NOT EXECUTED
    disk_end -= (disk_end % record_space);                                                
4000195c:   81 80 20 00     wr  %g0, %y                                                   
40001960:   01 00 00 00     nop                                                           
40001964:   01 00 00 00     nop                                                           
40001968:   01 00 00 00     nop                                                           
4000196c:   9a 73 40 10     udiv  %o5, %l0, %o5                                           
  if (count > 4) {                                                                        
40001970:   80 a0 60 04     cmp  %g1, 4                                                   
40001974:   18 80 00 0d     bgu  400019a8 <rtems_bdpart_create+0x240>                     <== ALWAYS TAKEN
40001978:   9a 5b 40 10     smul  %o5, %l0, %o5                                           
  overhead += record_space;                                                               
4000197c:   84 10 00 10     mov  %l0, %g2                                                 <== NOT EXECUTED
    overhead += (count - 1) * record_space;                                               
40001980:   9e 5c 00 03     smul  %l0, %g3, %o7                                           <== NOT EXECUTED
40001984:   10 bf ff b3     b  40001850 <rtems_bdpart_create+0xe8>                        <== NOT EXECUTED
40001988:   9e 03 c0 02     add  %o7, %g2, %o7                                            <== NOT EXECUTED
  pt [count - 1].end = disk_end;                                                          
4000198c:   87 28 60 01     sll  %g1, 1, %g3                                              
  return RTEMS_SUCCESSFUL;                                                                
40001990:   90 10 20 00     clr  %o0                                                      
  pt [count - 1].end = disk_end;                                                          
40001994:   82 00 c0 01     add  %g3, %g1, %g1                                            
40001998:   83 28 60 04     sll  %g1, 4, %g1                                              
4000199c:   82 06 80 01     add  %i2, %g1, %g1                                            
  return RTEMS_SUCCESSFUL;                                                                
400019a0:   10 bf ff e3     b  4000192c <rtems_bdpart_create+0x1c4>                       
400019a4:   da 20 7f d4     st  %o5, [ %g1 + -44 ]                                        
    overhead += (count - 3) * record_space;                                               
400019a8:   84 00 ff ff     add  %g3, -1, %g2                                             
    overhead += (count - 1) * record_space;                                               
400019ac:   9e 5c 00 03     smul  %l0, %g3, %o7                                           
    overhead += (count - 3) * record_space;                                               
400019b0:   84 58 80 10     smul  %g2, %l0, %g2                                           
    overhead += (count - 1) * record_space;                                               
400019b4:   10 bf ff a7     b  40001850 <rtems_bdpart_create+0xe8>                        
400019b8:   9e 03 c0 02     add  %o7, %g2, %o7                                            
===============================================================================
400019f8 <rtems_bdpart_dump>:                                                             
{                                                                                         
  uuid_unparse_lower( type, str);                                                         
}                                                                                         
                                                                                          
void rtems_bdpart_dump( const rtems_bdpart_partition *pt, size_t count)                   
{                                                                                         
400019f8:   9d e3 bf 60     save  %sp, -160, %sp                                          
  size_t i = 0;                                                                           
                                                                                          
  printf(                                                                                 
400019fc:   11 10 00 7d     sethi  %hi(0x4001f400), %o0                                   
40001a00:   7f ff ff 54     call  40001750 <__wrap_puts>                                  
40001a04:   90 12 22 70     or  %o0, 0x270, %o0 ! 4001f670 <test_state_strings+0x5c>      
    "------------+------------+-----------------------------------------------------\n"   
    " BEGIN      | LAST       | TYPE\n"                                                   
    "------------+------------+-----------------------------------------------------\n"   
  );                                                                                      
                                                                                          
  for (i = 0; i < count; ++i) {                                                           
40001a08:   80 a6 60 00     cmp  %i1, 0                                                   
40001a0c:   22 80 00 34     be,a   40001adc <rtems_bdpart_dump+0xe4>                      <== NEVER TAKEN
40001a10:   31 10 00 7d     sethi  %hi(0x4001f400), %i0                                   <== NOT EXECUTED
          break;                                                                          
        case RTEMS_BDPART_MBR_FAT_32_LBA:                                                 
          type = "FAT 32 LBA";                                                            
          break;                                                                          
        case RTEMS_BDPART_MBR_DATA:                                                       
          type = "DATA";                                                                  
40001a14:   37 10 00 7d     sethi  %hi(0x4001f400), %i3                                   
40001a18:   35 10 00 06     sethi  %hi(0x40001800), %i2                                   
          type = "FAT 12";                                                                
40001a1c:   25 10 00 7d     sethi  %hi(0x4001f400), %l2                                   
          type = "FAT 32 LBA";                                                            
40001a20:   23 10 00 7d     sethi  %hi(0x4001f400), %l1                                   
          type = "FAT 32";                                                                
40001a24:   21 10 00 7d     sethi  %hi(0x4001f400), %l0                                   
40001a28:   b0 06 20 08     add  %i0, 8, %i0                                              
  for (i = 0; i < count; ++i) {                                                           
40001a2c:   ba 10 20 00     clr  %i5                                                      
40001a30:   39 10 00 7d     sethi  %hi(0x4001f400), %i4                                   
          type = "DATA";                                                                  
40001a34:   b6 16 e2 68     or  %i3, 0x268, %i3                                           
40001a38:   b4 16 a1 bc     or  %i2, 0x1bc, %i2                                           
          type = "FAT 12";                                                                
40001a3c:   a4 14 a2 30     or  %l2, 0x230, %l2                                           
          type = "FAT 32 LBA";                                                            
40001a40:   a2 14 62 50     or  %l1, 0x250, %l1                                           
          type = "FAT 32";                                                                
40001a44:   a0 14 22 60     or  %l0, 0x260, %l0                                           
    uint8_t type_mbr = 0;                                                                 
40001a48:   c0 2f bf c7     clrb  [ %fp + -57 ]                                           
    if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {                        
40001a4c:   92 07 bf c7     add  %fp, -57, %o1                                            
40001a50:   40 00 00 9b     call  40001cbc <rtems_bdpart_to_mbr_partition_type>           
40001a54:   90 10 00 18     mov  %i0, %o0                                                 
40001a58:   80 a2 20 00     cmp  %o0, 0                                                   
40001a5c:   02 80 00 2b     be  40001b08 <rtems_bdpart_dump+0x110>                        <== NEVER TAKEN
40001a60:   c2 0f bf c7     ldub  [ %fp + -57 ], %g1                                      
      switch (type_mbr) {                                                                 
40001a64:   80 a0 60 0e     cmp  %g1, 0xe                                                 
40001a68:   18 80 00 09     bgu  40001a8c <rtems_bdpart_dump+0x94>                        <== NEVER TAKEN
40001a6c:   80 a0 60 00     cmp  %g1, 0                                                   
40001a70:   02 80 00 0a     be  40001a98 <rtems_bdpart_dump+0xa0>                         <== NEVER TAKEN
40001a74:   80 a0 60 0e     cmp  %g1, 0xe                                                 
40001a78:   18 80 00 08     bgu  40001a98 <rtems_bdpart_dump+0xa0>                        <== NEVER TAKEN
40001a7c:   85 28 60 02     sll  %g1, 2, %g2                                              
40001a80:   c4 06 80 02     ld  [ %i2 + %g2 ], %g2                                        
40001a84:   81 c0 80 00     jmp  %g2                                                      
40001a88:   01 00 00 00     nop                                                           
40001a8c:   80 a0 60 da     cmp  %g1, 0xda                                                <== NOT EXECUTED
40001a90:   02 80 00 09     be  40001ab4 <rtems_bdpart_dump+0xbc>                         <== NOT EXECUTED
40001a94:   96 10 00 1b     mov  %i3, %o3                                                 <== NOT EXECUTED
          break;                                                                          
        default:                                                                          
          snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);          
40001a98:   96 10 00 01     mov  %g1, %o3                                                 <== NOT EXECUTED
40001a9c:   92 10 20 34     mov  0x34, %o1                                                <== NOT EXECUTED
40001aa0:   15 10 00 7d     sethi  %hi(0x4001f400), %o2                                   <== NOT EXECUTED
40001aa4:   90 07 bf c8     add  %fp, -56, %o0                                            <== NOT EXECUTED
40001aa8:   40 00 4f 9c     call  40015918 <snprintf>                                     <== NOT EXECUTED
40001aac:   94 12 a3 b0     or  %o2, 0x3b0, %o2                                           <== NOT EXECUTED
          type = type_buffer;                                                             
40001ab0:   96 07 bf c8     add  %fp, -56, %o3                                            <== NOT EXECUTED
    } else {                                                                              
      rtems_bdpart_type_to_string( p->type, type_buffer);                                 
      type = type_buffer;                                                                 
    }                                                                                     
                                                                                          
    printf(                                                                               
40001ab4:   d4 06 3f fc     ld  [ %i0 + -4 ], %o2                                         
40001ab8:   d2 06 3f f8     ld  [ %i0 + -8 ], %o1                                         
40001abc:   94 02 bf ff     add  %o2, -1, %o2                                             
40001ac0:   7f ff ff 16     call  40001718 <__wrap_printf>                                
40001ac4:   90 17 23 c0     or  %i4, 0x3c0, %o0                                           
  for (i = 0; i < count; ++i) {                                                           
40001ac8:   ba 07 60 01     inc  %i5                                                      
40001acc:   80 a6 40 1d     cmp  %i1, %i5                                                 
40001ad0:   12 bf ff de     bne  40001a48 <rtems_bdpart_dump+0x50>                        
40001ad4:   b0 06 20 30     add  %i0, 0x30, %i0                                           
      p->end - 1U,                                                                        
      type                                                                                
    );                                                                                    
  }                                                                                       
                                                                                          
  puts( "------------+------------+-----------------------------------------------------");
40001ad8:   31 10 00 7d     sethi  %hi(0x4001f400), %i0                                   
40001adc:   7f ff ff 1d     call  40001750 <__wrap_puts>                                  
40001ae0:   91 ee 23 60     restore  %i0, 0x360, %o0                                      
          type = "FAT 16 LBA";                                                            
40001ae4:   17 10 00 7d     sethi  %hi(0x4001f400), %o3                                   <== NOT EXECUTED
          break;                                                                          
40001ae8:   10 bf ff f3     b  40001ab4 <rtems_bdpart_dump+0xbc>                          <== NOT EXECUTED
40001aec:   96 12 e2 38     or  %o3, 0x238, %o3 ! 4001f638 <test_state_strings+0x24>      <== NOT EXECUTED
          break;                                                                          
40001af0:   10 bf ff f1     b  40001ab4 <rtems_bdpart_dump+0xbc>                          <== NOT EXECUTED
40001af4:   96 10 00 11     mov  %l1, %o3                                                 <== NOT EXECUTED
          break;                                                                          
40001af8:   10 bf ff ef     b  40001ab4 <rtems_bdpart_dump+0xbc>                          
40001afc:   96 10 00 10     mov  %l0, %o3                                                 
          type = "FAT 12";                                                                
40001b00:   10 bf ff ed     b  40001ab4 <rtems_bdpart_dump+0xbc>                          <== NOT EXECUTED
40001b04:   96 10 00 12     mov  %l2, %o3                                                 <== NOT EXECUTED
  uuid_unparse_lower( type, str);                                                         
40001b08:   90 10 00 18     mov  %i0, %o0                                                 <== NOT EXECUTED
40001b0c:   40 00 17 87     call  40007928 <uuid_unparse_lower>                           <== NOT EXECUTED
40001b10:   92 07 bf c8     add  %fp, -56, %o1                                            <== NOT EXECUTED
      type = type_buffer;                                                                 
40001b14:   10 bf ff e8     b  40001ab4 <rtems_bdpart_dump+0xbc>                          <== NOT EXECUTED
40001b18:   96 07 bf c8     add  %fp, -56, %o3                                            <== NOT EXECUTED
      switch (type_mbr) {                                                                 
40001b1c:   17 10 00 7d     sethi  %hi(0x4001f400), %o3                                   <== NOT EXECUTED
40001b20:   10 bf ff e5     b  40001ab4 <rtems_bdpart_dump+0xbc>                          <== NOT EXECUTED
40001b24:   96 12 e2 48     or  %o3, 0x248, %o3 ! 4001f648 <test_state_strings+0x34>      <== NOT EXECUTED
                                                                                          
===============================================================================
40001cec <rtems_bdpart_get_disk_data>:                                                    
{                                                                                         
40001cec:   9d e3 bf 98     save  %sp, -104, %sp                                          
  fd = open( disk_name, O_RDWR);                                                          
40001cf0:   92 10 20 02     mov  2, %o1                                                   
40001cf4:   90 10 00 18     mov  %i0, %o0                                                 
  rtems_disk_device *dd = NULL;                                                           
40001cf8:   c0 27 bf fc     clr  [ %fp + -4 ]                                             
  fd = open( disk_name, O_RDWR);                                                          
40001cfc:   40 00 0a 95     call  40004750 <open>                                         
40001d00:   b0 10 20 03     mov  3, %i0                                                   
  if (fd < 0) {                                                                           
40001d04:   80 a2 20 00     cmp  %o0, 0                                                   
40001d08:   06 80 00 18     bl  40001d68 <rtems_bdpart_get_disk_data+0x7c>                <== NEVER TAKEN
40001d0c:   ba 10 00 08     mov  %o0, %i5                                                 
40001d10:   94 07 bf fc     add  %fp, -4, %o2                                             
40001d14:   13 10 01 10     sethi  %hi(0x40044000), %o1                                   
40001d18:   40 00 07 e8     call  40003cb8 <ioctl>                                        
40001d1c:   92 12 62 09     or  %o1, 0x209, %o1 ! 40044209 <__end+0x1e7d9>                
  if (rv != 0) {                                                                          
40001d20:   80 a2 20 00     cmp  %o0, 0                                                   
40001d24:   12 80 00 14     bne  40001d74 <rtems_bdpart_get_disk_data+0x88>               <== NEVER TAKEN
40001d28:   c2 07 bf fc     ld  [ %fp + -4 ], %g1                                         
  *disk_end = dd->size;                                                                   
40001d2c:   c4 00 60 1c     ld  [ %g1 + 0x1c ], %g2                                       
  disk_begin = dd->start;                                                                 
40001d30:   c6 00 60 18     ld  [ %g1 + 0x18 ], %g3                                       
  *disk_end = dd->size;                                                                   
40001d34:   c4 26 c0 00     st  %g2, [ %i3 ]                                              
  if (block_size < RTEMS_BDPART_BLOCK_SIZE) {                                             
40001d38:   c4 00 60 24     ld  [ %g1 + 0x24 ], %g2                                       
  if (disk_begin != 0) {                                                                  
40001d3c:   80 a0 a1 ff     cmp  %g2, 0x1ff                                               
40001d40:   08 80 00 0c     bleu  40001d70 <rtems_bdpart_get_disk_data+0x84>              <== NEVER TAKEN
40001d44:   80 a0 e0 00     cmp  %g3, 0                                                   
40001d48:   12 80 00 0a     bne  40001d70 <rtems_bdpart_get_disk_data+0x84>               <== NEVER TAKEN
40001d4c:   80 a6 60 00     cmp  %i1, 0                                                   
  if (sc == RTEMS_SUCCESSFUL && fd_ptr != NULL && dd_ptr != NULL) {                       
40001d50:   02 80 00 0d     be  40001d84 <rtems_bdpart_get_disk_data+0x98>                
40001d54:   80 a6 a0 00     cmp  %i2, 0                                                   
40001d58:   02 80 00 0c     be  40001d88 <rtems_bdpart_get_disk_data+0x9c>                <== NEVER TAKEN
40001d5c:   b0 10 20 00     clr  %i0                                                      
    *fd_ptr = fd;                                                                         
40001d60:   fa 26 40 00     st  %i5, [ %i1 ]                                              
    *dd_ptr = dd;                                                                         
40001d64:   c2 26 80 00     st  %g1, [ %i2 ]                                              
40001d68:   81 c7 e0 08     ret                                                           
40001d6c:   81 e8 00 00     restore                                                       
    sc = RTEMS_IO_ERROR;                                                                  
40001d70:   b0 10 20 1b     mov  0x1b, %i0                                                <== NOT EXECUTED
    close( fd);                                                                           
40001d74:   40 00 06 ea     call  4000391c <close>                                        <== NOT EXECUTED
40001d78:   90 10 00 1d     mov  %i5, %o0                                                 <== NOT EXECUTED
}                                                                                         
40001d7c:   81 c7 e0 08     ret                                                           
40001d80:   81 e8 00 00     restore                                                       
  rtems_status_code sc = RTEMS_SUCCESSFUL;                                                
40001d84:   b0 10 20 00     clr  %i0                                                      
    close( fd);                                                                           
40001d88:   40 00 06 e5     call  4000391c <close>                                        
40001d8c:   90 10 00 1d     mov  %i5, %o0                                                 
40001d90:   30 bf ff fb     b,a   40001d7c <rtems_bdpart_get_disk_data+0x90>              
                                                                                          
===============================================================================
40001d94 <rtems_bdpart_read>:                                                             
  const char *disk_name,                                                                  
  rtems_bdpart_format *format,                                                            
  rtems_bdpart_partition *pt,                                                             
  size_t *count                                                                           
)                                                                                         
{                                                                                         
40001d94:   9d e3 bf 88     save  %sp, -120, %sp                                          
  rtems_status_code sc = RTEMS_SUCCESSFUL;                                                
  rtems_status_code esc = RTEMS_SUCCESSFUL;                                               
  rtems_bdbuf_buffer *block = NULL;                                                       
  rtems_bdpart_partition *p = pt - 1;                                                     
40001d98:   82 06 bf d0     add  %i2, -48, %g1                                            
  rtems_bdbuf_buffer *block = NULL;                                                       
40001d9c:   c0 27 bf e8     clr  [ %fp + -24 ]                                            
  const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);                
40001da0:   80 a6 e0 00     cmp  %i3, 0                                                   
40001da4:   02 80 00 26     be  40001e3c <rtems_bdpart_read+0xa8>                         <== NEVER TAKEN
40001da8:   c2 27 bf ec     st  %g1, [ %fp + -20 ]                                        
  rtems_blkdev_bnum ep_begin = 0; /* Extended partition begin */                          
  rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */                       
  rtems_blkdev_bnum disk_end = 0;                                                         
  size_t i = 0;                                                                           
  const uint8_t *data = NULL;                                                             
  int fd = -1;                                                                            
40001dac:   82 10 3f ff     mov  -1, %g1                                                  
  rtems_blkdev_bnum ep_begin = 0; /* Extended partition begin */                          
40001db0:   c0 27 bf f0     clr  [ %fp + -16 ]                                            
  rtems_disk_device *dd = NULL;                                                           
                                                                                          
  /* Check parameter */                                                                   
  if (format == NULL || pt == NULL || count == NULL) {                                    
40001db4:   80 a6 60 00     cmp  %i1, 0                                                   
  rtems_blkdev_bnum disk_end = 0;                                                         
40001db8:   c0 27 bf f4     clr  [ %fp + -12 ]                                            
  int fd = -1;                                                                            
40001dbc:   c2 27 bf f8     st  %g1, [ %fp + -8 ]                                         
  rtems_disk_device *dd = NULL;                                                           
40001dc0:   c0 27 bf fc     clr  [ %fp + -4 ]                                             
  if (format == NULL || pt == NULL || count == NULL) {                                    
40001dc4:   02 80 00 1e     be  40001e3c <rtems_bdpart_read+0xa8>                         <== NEVER TAKEN
40001dc8:   f8 06 c0 00     ld  [ %i3 ], %i4                                              
40001dcc:   80 a6 a0 00     cmp  %i2, 0                                                   
40001dd0:   02 80 00 1b     be  40001e3c <rtems_bdpart_read+0xa8>                         <== NEVER TAKEN
40001dd4:   90 10 00 18     mov  %i0, %o0                                                 
    return RTEMS_INVALID_ADDRESS;                                                         
  }                                                                                       
                                                                                          
  /* Set count to a save value */                                                         
  *count = 0;                                                                             
40001dd8:   c0 26 c0 00     clr  [ %i3 ]                                                  
                                                                                          
  /* Get disk data */                                                                     
  sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);                       
40001ddc:   96 07 bf f4     add  %fp, -12, %o3                                            
40001de0:   94 07 bf fc     add  %fp, -4, %o2                                             
40001de4:   7f ff ff c2     call  40001cec <rtems_bdpart_get_disk_data>                   
40001de8:   92 07 bf f8     add  %fp, -8, %o1                                             
  if (sc != RTEMS_SUCCESSFUL) {                                                           
40001dec:   b0 92 20 00     orcc  %o0, 0, %i0                                             
40001df0:   12 80 00 11     bne  40001e34 <rtems_bdpart_read+0xa0>                        <== NEVER TAKEN
40001df4:   d0 07 bf fc     ld  [ %fp + -4 ], %o0                                         
    return sc;                                                                            
  }                                                                                       
                                                                                          
  /* Read MBR */                                                                          
  sc = rtems_bdpart_read_record( dd, 0, &block);                                          
40001df8:   92 10 20 00     clr  %o1                                                      
40001dfc:   7f ff ff 87     call  40001c18 <rtems_bdpart_read_record>                     
40001e00:   94 07 bf e8     add  %fp, -24, %o2                                            
  if (sc != RTEMS_SUCCESSFUL) {                                                           
40001e04:   b0 92 20 00     orcc  %o0, 0, %i0                                             
40001e08:   02 80 00 0f     be  40001e44 <rtems_bdpart_read+0xb0>                         <== ALWAYS TAKEN
40001e0c:   c2 07 bf e8     ld  [ %fp + -24 ], %g1                                        
  /* Return partition count */                                                            
  *count = (size_t) (p - pt + 1);                                                         
                                                                                          
cleanup:                                                                                  
                                                                                          
  if (fd >= 0) {                                                                          
40001e10:   c2 07 bf f8     ld  [ %fp + -8 ], %g1                                         
40001e14:   80 a0 60 00     cmp  %g1, 0                                                   
40001e18:   16 80 00 75     bge  40001fec <rtems_bdpart_read+0x258>                       <== ALWAYS TAKEN
40001e1c:   d0 07 bf e8     ld  [ %fp + -24 ], %o0                                        
    close( fd);                                                                           
  }                                                                                       
                                                                                          
  if (block != NULL) {                                                                    
40001e20:   80 a2 20 00     cmp  %o0, 0                                                   <== NOT EXECUTED
40001e24:   02 80 00 04     be  40001e34 <rtems_bdpart_read+0xa0>                         <== NOT EXECUTED
40001e28:   01 00 00 00     nop                                                           <== NOT EXECUTED
    rtems_bdbuf_release( block);                                                          
40001e2c:   40 00 34 a2     call  4000f0b4 <rtems_bdbuf_release>                          
40001e30:   01 00 00 00     nop                                                           
40001e34:   81 c7 e0 08     ret                                                           
40001e38:   81 e8 00 00     restore                                                       
    return RTEMS_INVALID_ADDRESS;                                                         
40001e3c:   81 c7 e0 08     ret                                                           <== NOT EXECUTED
40001e40:   91 e8 20 09     restore  %g0, 9, %o0                                          <== NOT EXECUTED
  data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;                                 
40001e44:   e0 00 60 1c     ld  [ %g1 + 0x1c ], %l0                                       
  const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);                
40001e48:   83 2f 20 01     sll  %i4, 1, %g1                                              
  data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;                                 
40001e4c:   ba 04 21 be     add  %l0, 0x1be, %i5                                          
  const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);                
40001e50:   b8 00 40 1c     add  %g1, %i4, %i4                                            
  sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);                      
40001e54:   96 07 bf f0     add  %fp, -16, %o3                                            
  const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);                
40001e58:   b9 2f 20 04     sll  %i4, 4, %i4                                              
  sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);                      
40001e5c:   92 07 bf ec     add  %fp, -20, %o1                                            
  const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);                
40001e60:   b8 06 80 1c     add  %i2, %i4, %i4                                            
  sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);                      
40001e64:   90 10 00 1d     mov  %i5, %o0                                                 
40001e68:   7f ff ff 30     call  40001b28 <rtems_bdpart_read_mbr_partition>              
40001e6c:   94 10 00 1c     mov  %i4, %o2                                                 
  if (sc != RTEMS_SUCCESSFUL) {                                                           
40001e70:   b0 92 20 00     orcc  %o0, 0, %i0                                             
40001e74:   12 bf ff e7     bne  40001e10 <rtems_bdpart_read+0x7c>                        <== NEVER TAKEN
40001e78:   c2 07 bf ec     ld  [ %fp + -20 ], %g1                                        
  if (rtems_bdpart_mbr_partition_type( p->type) == RTEMS_BDPART_MBR_GPT) {                
40001e7c:   c2 08 60 08     ldub  [ %g1 + 8 ], %g1                                        
40001e80:   80 a0 60 ee     cmp  %g1, 0xee                                                
40001e84:   02 80 00 63     be  40002010 <rtems_bdpart_read+0x27c>                        <== NEVER TAKEN
40001e88:   c4 07 bf e8     ld  [ %fp + -24 ], %g2                                        
  format->type = RTEMS_BDPART_FORMAT_MBR;                                                 
40001e8c:   c0 26 40 00     clr  [ %i1 ]                                                  
40001e90:   82 10 20 03     mov  3, %g1                                                   
    block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID                                       
40001e94:   c6 00 a0 1c     ld  [ %g2 + 0x1c ], %g3                                       
40001e98:   86 00 e1 b8     add  %g3, 0x1b8, %g3                                          
    value = (value << 8) + data [i];                                                      
40001e9c:   c4 08 c0 01     ldub  [ %g3 + %g1 ], %g2                                      
40001ea0:   b1 2e 20 08     sll  %i0, 8, %i0                                              
  for (i = 3; i >= 0; --i) {                                                              
40001ea4:   82 00 7f ff     add  %g1, -1, %g1                                             
40001ea8:   80 a0 7f ff     cmp  %g1, -1                                                  
40001eac:   12 bf ff fc     bne  40001e9c <rtems_bdpart_read+0x108>                       
40001eb0:   b0 00 80 18     add  %g2, %i0, %i0                                            
  format->mbr.dos_compatibility = true;                                                   
40001eb4:   82 10 20 01     mov  1, %g1                                                   
  format->mbr.disk_id = rtems_uint32_from_little_endian(                                  
40001eb8:   f0 26 60 04     st  %i0, [ %i1 + 4 ]                                          
  format->mbr.dos_compatibility = true;                                                   
40001ebc:   a0 04 21 ee     add  %l0, 0x1ee, %l0                                          
40001ec0:   c2 2e 60 08     stb  %g1, [ %i1 + 8 ]                                         
    data += RTEMS_BDPART_MBR_TABLE_ENTRY_SIZE;                                            
40001ec4:   ba 07 60 10     add  %i5, 0x10, %i5                                           
    sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);                    
40001ec8:   96 07 bf f0     add  %fp, -16, %o3                                            
40001ecc:   94 10 00 1c     mov  %i4, %o2                                                 
40001ed0:   92 07 bf ec     add  %fp, -20, %o1                                            
40001ed4:   7f ff ff 15     call  40001b28 <rtems_bdpart_read_mbr_partition>              
40001ed8:   90 10 00 1d     mov  %i5, %o0                                                 
    if (sc != RTEMS_SUCCESSFUL) {                                                         
40001edc:   b0 92 20 00     orcc  %o0, 0, %i0                                             
40001ee0:   12 bf ff cc     bne  40001e10 <rtems_bdpart_read+0x7c>                        <== NEVER TAKEN
40001ee4:   80 a7 40 10     cmp  %i5, %l0                                                 
  for (i = 1; i < 4; ++i) {                                                               
40001ee8:   12 bf ff f8     bne  40001ec8 <rtems_bdpart_read+0x134>                       
40001eec:   ba 07 60 10     add  %i5, 0x10, %i5                                           
  ebr = ep_begin;                                                                         
40001ef0:   fa 07 bf f0     ld  [ %fp + -16 ], %i5                                        
  while (ebr != 0) {                                                                      
40001ef4:   80 a7 60 00     cmp  %i5, 0                                                   
40001ef8:   02 80 00 2d     be  40001fac <rtems_bdpart_read+0x218>                        <== NEVER TAKEN
40001efc:   c8 07 bf ec     ld  [ %fp + -20 ], %g4                                        
    sc = rtems_bdpart_read_record( dd, ebr, &block);                                      
40001f00:   d0 07 bf fc     ld  [ %fp + -4 ], %o0                                         
40001f04:   94 07 bf e8     add  %fp, -24, %o2                                            
40001f08:   7f ff ff 44     call  40001c18 <rtems_bdpart_read_record>                     
40001f0c:   92 10 00 1d     mov  %i5, %o1                                                 
    if (sc != RTEMS_SUCCESSFUL) {                                                         
40001f10:   80 a2 20 00     cmp  %o0, 0                                                   
40001f14:   12 80 00 41     bne  40002018 <rtems_bdpart_read+0x284>                       <== NEVER TAKEN
40001f18:   c2 07 bf e8     ld  [ %fp + -24 ], %g1                                        
      block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,                                    
40001f1c:   d0 00 60 1c     ld  [ %g1 + 0x1c ], %o0                                       
    sc = rtems_bdpart_read_mbr_partition(                                                 
40001f20:   96 10 20 00     clr  %o3                                                      
40001f24:   94 10 00 1c     mov  %i4, %o2                                                 
40001f28:   92 07 bf ec     add  %fp, -20, %o1                                            
40001f2c:   7f ff fe ff     call  40001b28 <rtems_bdpart_read_mbr_partition>              
40001f30:   90 02 21 be     add  %o0, 0x1be, %o0                                          
    if (sc != RTEMS_SUCCESSFUL) {                                                         
40001f34:   82 92 20 00     orcc  %o0, 0, %g1                                             
40001f38:   12 80 00 3a     bne  40002020 <rtems_bdpart_read+0x28c>                       <== NEVER TAKEN
40001f3c:   c8 07 bf ec     ld  [ %fp + -20 ], %g4                                        
    tmp = p->begin + ebr;                                                                 
40001f40:   c4 01 00 00     ld  [ %g4 ], %g2                                              
40001f44:   86 00 80 1d     add  %g2, %i5, %g3                                            
    if (tmp > p->begin) {                                                                 
40001f48:   80 a0 80 03     cmp  %g2, %g3                                                 
40001f4c:   3a bf ff b1     bcc,a   40001e10 <rtems_bdpart_read+0x7c>                     <== NEVER TAKEN
40001f50:   b0 10 20 1b     mov  0x1b, %i0                                                <== NOT EXECUTED
      p->begin = tmp;                                                                     
40001f54:   c6 21 00 00     st  %g3, [ %g4 ]                                              
    tmp = p->end + ebr;                                                                   
40001f58:   c4 01 20 04     ld  [ %g4 + 4 ], %g2                                          
40001f5c:   ba 00 80 1d     add  %g2, %i5, %i5                                            
    if (tmp > p->end) {                                                                   
40001f60:   80 a0 80 1d     cmp  %g2, %i5                                                 
40001f64:   1a 80 00 29     bcc  40002008 <rtems_bdpart_read+0x274>                       <== NEVER TAKEN
40001f68:   d0 07 bf e8     ld  [ %fp + -24 ], %o0                                        
      block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1                                     
40001f6c:   f2 02 20 1c     ld  [ %o0 + 0x1c ], %i1                                       
      p->end = tmp;                                                                       
40001f70:   fa 21 20 04     st  %i5, [ %g4 + 4 ]                                          
40001f74:   84 10 20 03     mov  3, %g2                                                   
40001f78:   ba 06 61 d6     add  %i1, 0x1d6, %i5                                          
    value = (value << 8) + data [i];                                                      
40001f7c:   c6 0f 40 02     ldub  [ %i5 + %g2 ], %g3                                      
40001f80:   83 28 60 08     sll  %g1, 8, %g1                                              
  for (i = 3; i >= 0; --i) {                                                              
40001f84:   84 00 bf ff     add  %g2, -1, %g2                                             
40001f88:   80 a0 bf ff     cmp  %g2, -1                                                  
40001f8c:   12 bf ff fc     bne  40001f7c <rtems_bdpart_read+0x1e8>                       
40001f90:   82 00 c0 01     add  %g3, %g1, %g1                                            
  if (type == RTEMS_BDPART_MBR_EXTENDED) {                                                
40001f94:   c4 0e 61 d2     ldub  [ %i1 + 0x1d2 ], %g2                                    
    if (ebr != 0) {                                                                       
40001f98:   80 a0 a0 05     cmp  %g2, 5                                                   
40001f9c:   12 80 00 04     bne  40001fac <rtems_bdpart_read+0x218>                       
40001fa0:   80 a0 60 00     cmp  %g1, 0                                                   
40001fa4:   32 80 00 0a     bne,a   40001fcc <rtems_bdpart_read+0x238>                    <== ALWAYS TAKEN
40001fa8:   fa 07 bf f0     ld  [ %fp + -16 ], %i5                                        
  *count = (size_t) (p - pt + 1);                                                         
40001fac:   82 21 00 1a     sub  %g4, %i2, %g1                                            
40001fb0:   05 2a aa aa     sethi  %hi(0xaaaaa800), %g2                                   
40001fb4:   83 38 60 04     sra  %g1, 4, %g1                                              
40001fb8:   84 10 a2 ab     or  %g2, 0x2ab, %g2                                           
40001fbc:   82 58 40 02     smul  %g1, %g2, %g1                                           
40001fc0:   82 00 60 01     inc  %g1                                                      
40001fc4:   10 bf ff 93     b  40001e10 <rtems_bdpart_read+0x7c>                          
40001fc8:   c2 26 c0 00     st  %g1, [ %i3 ]                                              
      tmp = ebr + ep_begin;                                                               
40001fcc:   ba 00 40 1d     add  %g1, %i5, %i5                                            
      if (tmp > ebr) {                                                                    
40001fd0:   80 a7 40 01     cmp  %i5, %g1                                                 
40001fd4:   38 bf ff cc     bgu,a   40001f04 <rtems_bdpart_read+0x170>                    <== ALWAYS TAKEN
40001fd8:   d0 07 bf fc     ld  [ %fp + -4 ], %o0                                         
  if (fd >= 0) {                                                                          
40001fdc:   c2 07 bf f8     ld  [ %fp + -8 ], %g1                                         <== NOT EXECUTED
40001fe0:   80 a0 60 00     cmp  %g1, 0                                                   <== NOT EXECUTED
40001fe4:   06 bf ff 92     bl  40001e2c <rtems_bdpart_read+0x98>                         <== NOT EXECUTED
40001fe8:   b0 10 20 1b     mov  0x1b, %i0                                                <== NOT EXECUTED
    close( fd);                                                                           
40001fec:   40 00 06 4c     call  4000391c <close>                                        
40001ff0:   90 10 00 01     mov  %g1, %o0                                                 
  if (block != NULL) {                                                                    
40001ff4:   d0 07 bf e8     ld  [ %fp + -24 ], %o0                                        
40001ff8:   80 a2 20 00     cmp  %o0, 0                                                   
40001ffc:   12 bf ff 8c     bne  40001e2c <rtems_bdpart_read+0x98>                        <== ALWAYS TAKEN
40002000:   01 00 00 00     nop                                                           
40002004:   30 bf ff 8c     b,a   40001e34 <rtems_bdpart_read+0xa0>                       <== NOT EXECUTED
      esc = RTEMS_IO_ERROR;                                                               
40002008:   10 bf ff 82     b  40001e10 <rtems_bdpart_read+0x7c>                          <== NOT EXECUTED
4000200c:   b0 10 20 1b     mov  0x1b, %i0                                                <== NOT EXECUTED
    esc = RTEMS_NOT_IMPLEMENTED;                                                          
40002010:   10 bf ff 80     b  40001e10 <rtems_bdpart_read+0x7c>                          <== NOT EXECUTED
40002014:   b0 10 20 18     mov  0x18, %i0                                                <== NOT EXECUTED
40002018:   10 bf ff 7e     b  40001e10 <rtems_bdpart_read+0x7c>                          <== NOT EXECUTED
4000201c:   b0 10 00 08     mov  %o0, %i0                                                 <== NOT EXECUTED
40002020:   10 bf ff 7c     b  40001e10 <rtems_bdpart_read+0x7c>                          <== NOT EXECUTED
40002024:   b0 10 00 01     mov  %g1, %i0                                                 <== NOT EXECUTED
                                                                                          
===============================================================================
40002028 <rtems_bdpart_register>:                                                         
rtems_status_code rtems_bdpart_register(                                                  
  const char *disk_name,                                                                  
  const rtems_bdpart_partition *pt,                                                       
  size_t count                                                                            
)                                                                                         
{                                                                                         
40002028:   9d e3 bf 90     save  %sp, -112, %sp                                          
  rtems_status_code esc = RTEMS_SUCCESSFUL;                                               
  rtems_blkdev_bnum disk_end = 0;                                                         
  char *logical_disk_name = NULL;                                                         
  char *logical_disk_marker = NULL;                                                       
  size_t i = 0;                                                                           
  int fd = -1;                                                                            
4000202c:   82 10 3f ff     mov  -1, %g1                                                  
  rtems_blkdev_bnum disk_end = 0;                                                         
40002030:   c0 27 bf f4     clr  [ %fp + -12 ]                                            
  rtems_disk_device *dd = NULL;                                                           
                                                                                          
  /* Get disk data */                                                                     
  sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);                       
40002034:   96 07 bf f4     add  %fp, -12, %o3                                            
  rtems_disk_device *dd = NULL;                                                           
40002038:   c0 27 bf fc     clr  [ %fp + -4 ]                                             
  sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);                       
4000203c:   94 07 bf fc     add  %fp, -4, %o2                                             
  int fd = -1;                                                                            
40002040:   c2 27 bf f8     st  %g1, [ %fp + -8 ]                                         
  sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);                       
40002044:   92 07 bf f8     add  %fp, -8, %o1                                             
40002048:   7f ff ff 29     call  40001cec <rtems_bdpart_get_disk_data>                   
4000204c:   90 10 00 18     mov  %i0, %o0                                                 
  if (sc != RTEMS_SUCCESSFUL) {                                                           
40002050:   b6 92 20 00     orcc  %o0, 0, %i3                                             
40002054:   02 80 00 04     be  40002064 <rtems_bdpart_register+0x3c>                     <== ALWAYS TAKEN
40002058:   01 00 00 00     nop                                                           
                                                                                          
  free( logical_disk_name);                                                               
  close( fd);                                                                             
                                                                                          
  return esc;                                                                             
}                                                                                         
4000205c:   81 c7 e0 08     ret                                                           <== NOT EXECUTED
40002060:   91 e8 00 1b     restore  %g0, %i3, %o0                                        <== NOT EXECUTED
  size_t disk_name_size = strlen( disk_name);                                             
40002064:   40 00 4f 19     call  40015cc8 <strlen>                                       
40002068:   90 10 00 18     mov  %i0, %o0                                                 
4000206c:   ba 10 00 08     mov  %o0, %i5                                                 
  char *logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);           
40002070:   40 00 07 dc     call  40003fe0 <malloc>                                       
40002074:   90 02 20 04     add  %o0, 4, %o0                                              
  if (logical_disk_name != NULL) {                                                        
40002078:   b8 92 20 00     orcc  %o0, 0, %i4                                             
4000207c:   02 80 00 1f     be  400020f8 <rtems_bdpart_register+0xd0>                     <== NEVER TAKEN
40002080:   94 10 00 1d     mov  %i5, %o2                                                 
    memcpy( logical_disk_name, disk_name, disk_name_size);                                
40002084:   92 10 00 18     mov  %i0, %o1                                                 
    *marker = logical_disk_name + disk_name_size;                                         
40002088:   a2 07 00 1d     add  %i4, %i5, %l1                                            
    memcpy( logical_disk_name, disk_name, disk_name_size);                                
4000208c:   40 00 4d 43     call  40015598 <memcpy>                                       
40002090:   21 10 00 7d     sethi  %hi(0x4001f400), %l0                                   
  for (i = 0; i < count; ++i) {                                                           
40002094:   ba 10 20 00     clr  %i5                                                      
  rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);            
40002098:   10 80 00 09     b  400020bc <rtems_bdpart_register+0x94>                      
4000209c:   a0 14 23 e8     or  %l0, 0x3e8, %l0                                           
    sc = rtems_blkdev_create_partition(                                                   
400020a0:   d4 1e 40 00     ldd  [ %i1 ], %o2                                             
400020a4:   96 22 c0 0a     sub  %o3, %o2, %o3                                            
400020a8:   40 00 02 af     call  40002b64 <rtems_blkdev_create_partition>                
400020ac:   b2 06 60 30     add  %i1, 0x30, %i1                                           
    if (sc != RTEMS_SUCCESSFUL) {                                                         
400020b0:   80 a2 20 00     cmp  %o0, 0                                                   
400020b4:   32 80 00 11     bne,a   400020f8 <rtems_bdpart_register+0xd0>                 <== NEVER TAKEN
400020b8:   b6 10 00 08     mov  %o0, %i3                                                 <== NOT EXECUTED
  for (i = 0; i < count; ++i) {                                                           
400020bc:   80 a7 40 1a     cmp  %i5, %i2                                                 
  rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);            
400020c0:   94 10 00 10     mov  %l0, %o2                                                 
400020c4:   ba 07 60 01     inc  %i5                                                      
400020c8:   92 10 20 04     mov  4, %o1                                                   
400020cc:   90 10 00 11     mov  %l1, %o0                                                 
  for (i = 0; i < count; ++i) {                                                           
400020d0:   02 80 00 0a     be  400020f8 <rtems_bdpart_register+0xd0>                     
400020d4:   96 10 00 1d     mov  %i5, %o3                                                 
  rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);            
400020d8:   40 00 4e 10     call  40015918 <snprintf>                                     
400020dc:   01 00 00 00     nop                                                           
    sc = rtems_blkdev_create_partition(                                                   
400020e0:   92 10 00 18     mov  %i0, %o1                                                 
  rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);            
400020e4:   82 10 00 08     mov  %o0, %g1                                                 
  if (rv >= RTEMS_BDPART_NUMBER_SIZE) {                                                   
400020e8:   80 a0 60 03     cmp  %g1, 3                                                   
400020ec:   04 bf ff ed     ble  400020a0 <rtems_bdpart_register+0x78>                    <== ALWAYS TAKEN
400020f0:   90 10 00 1c     mov  %i4, %o0                                                 
    sc = RTEMS_INVALID_NAME;                                                              
400020f4:   b6 10 20 03     mov  3, %i3                                                   <== NOT EXECUTED
  free( logical_disk_name);                                                               
400020f8:   40 00 06 6b     call  40003aa4 <free>                                         
400020fc:   90 10 00 1c     mov  %i4, %o0                                                 
  close( fd);                                                                             
40002100:   40 00 06 07     call  4000391c <close>                                        
40002104:   d0 07 bf f8     ld  [ %fp + -8 ], %o0                                         
}                                                                                         
40002108:   81 c7 e0 08     ret                                                           
4000210c:   91 e8 00 1b     restore  %g0, %i3, %o0                                        
                                                                                          
===============================================================================
40002110 <rtems_bdpart_register_from_disk>:                                               
                                                                                          
rtems_status_code rtems_bdpart_register_from_disk( const char *disk_name)                 
{                                                                                         
40002110:   9d e3 bc 88     save  %sp, -888, %sp                                          
  rtems_status_code sc = RTEMS_SUCCESSFUL;                                                
  rtems_bdpart_format format;                                                             
  rtems_bdpart_partition pt [RTEMS_BDPART_PARTITION_NUMBER_HINT];                         
  size_t count = RTEMS_BDPART_PARTITION_NUMBER_HINT;                                      
40002114:   82 10 20 10     mov  0x10, %g1                                                
                                                                                          
  /* Read partitions */                                                                   
  sc = rtems_bdpart_read( disk_name, &format, pt, &count);                                
40002118:   96 07 bc e8     add  %fp, -792, %o3                                           
  size_t count = RTEMS_BDPART_PARTITION_NUMBER_HINT;                                      
4000211c:   c2 27 bc e8     st  %g1, [ %fp + -792 ]                                       
  sc = rtems_bdpart_read( disk_name, &format, pt, &count);                                
40002120:   94 07 bd 00     add  %fp, -768, %o2                                           
40002124:   92 07 bc ec     add  %fp, -788, %o1                                           
40002128:   7f ff ff 1b     call  40001d94 <rtems_bdpart_read>                            
4000212c:   90 10 00 18     mov  %i0, %o0                                                 
  if (sc != RTEMS_SUCCESSFUL) {                                                           
40002130:   80 a2 20 00     cmp  %o0, 0                                                   
40002134:   12 80 00 05     bne  40002148 <rtems_bdpart_register_from_disk+0x38>          <== NEVER TAKEN
40002138:   d4 07 bc e8     ld  [ %fp + -792 ], %o2                                       
    return sc;                                                                            
  }                                                                                       
                                                                                          
  /* Register partitions */                                                               
  return rtems_bdpart_register( disk_name, pt, count);                                    
4000213c:   92 07 bd 00     add  %fp, -768, %o1                                           
40002140:   7f ff ff ba     call  40002028 <rtems_bdpart_register>                        
40002144:   90 10 00 18     mov  %i0, %o0                                                 
}                                                                                         
40002148:   81 c7 e0 08     ret                                                           
4000214c:   91 e8 00 08     restore  %g0, %o0, %o0                                        
                                                                                          
===============================================================================
40002150 <rtems_bdpart_unregister>:                                                       
rtems_status_code rtems_bdpart_unregister(                                                
  const char *disk_name,                                                                  
  const rtems_bdpart_partition *pt RTEMS_UNUSED,                                          
  size_t count                                                                            
)                                                                                         
{                                                                                         
40002150:   9d e3 bf 90     save  %sp, -112, %sp                                          
  rtems_status_code esc = RTEMS_SUCCESSFUL;                                               
  rtems_blkdev_bnum disk_end = 0;                                                         
  char *logical_disk_name = NULL;                                                         
  char *logical_disk_marker = NULL;                                                       
  size_t i = 0;                                                                           
  int fd = -1;                                                                            
40002154:   82 10 3f ff     mov  -1, %g1                                                  
  rtems_blkdev_bnum disk_end = 0;                                                         
40002158:   c0 27 bf f4     clr  [ %fp + -12 ]                                            
  rtems_disk_device *dd = NULL;                                                           
                                                                                          
  /* Get disk data */                                                                     
  sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);                       
4000215c:   96 07 bf f4     add  %fp, -12, %o3                                            
  rtems_disk_device *dd = NULL;                                                           
40002160:   c0 27 bf fc     clr  [ %fp + -4 ]                                             
  sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);                       
40002164:   94 07 bf fc     add  %fp, -4, %o2                                             
  int fd = -1;                                                                            
40002168:   c2 27 bf f8     st  %g1, [ %fp + -8 ]                                         
  sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);                       
4000216c:   92 07 bf f8     add  %fp, -8, %o1                                             
40002170:   7f ff fe df     call  40001cec <rtems_bdpart_get_disk_data>                   
40002174:   90 10 00 18     mov  %i0, %o0                                                 
  if (sc != RTEMS_SUCCESSFUL) {                                                           
40002178:   b6 92 20 00     orcc  %o0, 0, %i3                                             
4000217c:   02 80 00 04     be  4000218c <rtems_bdpart_unregister+0x3c>                   <== ALWAYS TAKEN
40002180:   01 00 00 00     nop                                                           
                                                                                          
  free( logical_disk_name);                                                               
  close( fd);                                                                             
                                                                                          
  return esc;                                                                             
}                                                                                         
40002184:   81 c7 e0 08     ret                                                           <== NOT EXECUTED
40002188:   91 e8 00 1b     restore  %g0, %i3, %o0                                        <== NOT EXECUTED
  size_t disk_name_size = strlen( disk_name);                                             
4000218c:   40 00 4e cf     call  40015cc8 <strlen>                                       
40002190:   90 10 00 18     mov  %i0, %o0                                                 
40002194:   ba 10 00 08     mov  %o0, %i5                                                 
  char *logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);           
40002198:   40 00 07 92     call  40003fe0 <malloc>                                       
4000219c:   90 02 20 04     add  %o0, 4, %o0                                              
  if (logical_disk_name != NULL) {                                                        
400021a0:   b8 92 20 00     orcc  %o0, 0, %i4                                             
400021a4:   02 80 00 1c     be  40002214 <rtems_bdpart_unregister+0xc4>                   <== NEVER TAKEN
400021a8:   94 10 00 1d     mov  %i5, %o2                                                 
    memcpy( logical_disk_name, disk_name, disk_name_size);                                
400021ac:   92 10 00 18     mov  %i0, %o1                                                 
  rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);            
400021b0:   33 10 00 7d     sethi  %hi(0x4001f400), %i1                                   
    memcpy( logical_disk_name, disk_name, disk_name_size);                                
400021b4:   40 00 4c f9     call  40015598 <memcpy>                                       
400021b8:   b0 07 00 1d     add  %i4, %i5, %i0                                            
  for (i = 0; i < count; ++i) {                                                           
400021bc:   ba 10 20 00     clr  %i5                                                      
  rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);            
400021c0:   10 80 00 07     b  400021dc <rtems_bdpart_unregister+0x8c>                    
400021c4:   b2 16 63 e8     or  %i1, 0x3e8, %i1                                           
    rv = unlink( logical_disk_name);                                                      
400021c8:   40 00 0e 26     call  40005a60 <unlink>                                       
400021cc:   01 00 00 00     nop                                                           
    if (rv != 0) {                                                                        
400021d0:   80 a2 20 00     cmp  %o0, 0                                                   
400021d4:   12 80 00 10     bne  40002214 <rtems_bdpart_unregister+0xc4>                  <== NEVER TAKEN
400021d8:   01 00 00 00     nop                                                           
  for (i = 0; i < count; ++i) {                                                           
400021dc:   80 a7 40 1a     cmp  %i5, %i2                                                 
  rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);            
400021e0:   94 10 00 19     mov  %i1, %o2                                                 
400021e4:   ba 07 60 01     inc  %i5                                                      
400021e8:   92 10 20 04     mov  4, %o1                                                   
400021ec:   90 10 00 18     mov  %i0, %o0                                                 
  for (i = 0; i < count; ++i) {                                                           
400021f0:   02 80 00 09     be  40002214 <rtems_bdpart_unregister+0xc4>                   
400021f4:   96 10 00 1d     mov  %i5, %o3                                                 
  rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);            
400021f8:   40 00 4d c8     call  40015918 <snprintf>                                     
400021fc:   01 00 00 00     nop                                                           
40002200:   82 10 00 08     mov  %o0, %g1                                                 
  if (rv >= RTEMS_BDPART_NUMBER_SIZE) {                                                   
40002204:   80 a0 60 03     cmp  %g1, 3                                                   
40002208:   04 bf ff f0     ble  400021c8 <rtems_bdpart_unregister+0x78>                  <== ALWAYS TAKEN
4000220c:   90 10 00 1c     mov  %i4, %o0                                                 
    sc = RTEMS_INVALID_NAME;                                                              
40002210:   b6 10 20 03     mov  3, %i3                                                   <== NOT EXECUTED
  free( logical_disk_name);                                                               
40002214:   40 00 06 24     call  40003aa4 <free>                                         
40002218:   90 10 00 1c     mov  %i4, %o0                                                 
  close( fd);                                                                             
4000221c:   40 00 05 c0     call  4000391c <close>                                        
40002220:   d0 07 bf f8     ld  [ %fp + -8 ], %o0                                         
}                                                                                         
40002224:   81 c7 e0 08     ret                                                           
40002228:   91 e8 00 1b     restore  %g0, %i3, %o0                                        
                                                                                          
===============================================================================
400022b8 <rtems_bdpart_write>:                                                            
  const char *disk_name,                                                                  
  const rtems_bdpart_format *format,                                                      
  const rtems_bdpart_partition *pt,                                                       
  size_t count                                                                            
)                                                                                         
{                                                                                         
400022b8:   9d e3 bf 88     save  %sp, -120, %sp                                          
  rtems_status_code sc = RTEMS_SUCCESSFUL;                                                
  rtems_status_code esc = RTEMS_SUCCESSFUL;                                               
  bool dos_compatibility = format != NULL                                                 
    && format->type == RTEMS_BDPART_FORMAT_MBR                                            
    && format->mbr.dos_compatibility;                                                     
400022bc:   80 a6 60 00     cmp  %i1, 0                                                   
400022c0:   22 80 00 07     be,a   400022dc <rtems_bdpart_write+0x24>                     <== NEVER TAKEN
400022c4:   c0 27 bf f0     clr  [ %fp + -16 ]                                            <== NOT EXECUTED
    && format->type == RTEMS_BDPART_FORMAT_MBR                                            
400022c8:   c2 06 40 00     ld  [ %i1 ], %g1                                              
400022cc:   80 a0 60 00     cmp  %g1, 0                                                   
400022d0:   22 80 00 54     be,a   40002420 <rtems_bdpart_write+0x168>                    <== ALWAYS TAKEN
400022d4:   c2 0e 60 08     ldub  [ %i1 + 8 ], %g1                                        
  rtems_bdbuf_buffer *block = NULL;                                                       
400022d8:   c0 27 bf f0     clr  [ %fp + -16 ]                                            <== NOT EXECUTED
    && format->mbr.dos_compatibility;                                                     
400022dc:   a0 10 20 00     clr  %l0                                                      <== NOT EXECUTED
  rtems_blkdev_bnum disk_end = 0;                                                         
400022e0:   c0 27 bf f4     clr  [ %fp + -12 ]                                            <== NOT EXECUTED
  rtems_blkdev_bnum record_space =                                                        
    dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;                               
400022e4:   a2 10 20 01     mov  1, %l1                                                   <== NOT EXECUTED
  size_t ppc = 0; /* Primary partition count */                                           
  size_t i = 0;                                                                           
  uint8_t *data = NULL;                                                                   
  int fd = -1;                                                                            
400022e8:   82 10 3f ff     mov  -1, %g1                                                  
  rtems_disk_device *dd = NULL;                                                           
400022ec:   c0 27 bf fc     clr  [ %fp + -4 ]                                             
                                                                                          
  /* Check if we have something to do */                                                  
  if (count == 0) {                                                                       
    /* Nothing to do */                                                                   
    return RTEMS_SUCCESSFUL;                                                              
400022f0:   ba 10 20 00     clr  %i5                                                      
  if (count == 0) {                                                                       
400022f4:   80 a6 e0 00     cmp  %i3, 0                                                   
400022f8:   02 80 00 48     be  40002418 <rtems_bdpart_write+0x160>                       <== NEVER TAKEN
400022fc:   c2 27 bf f8     st  %g1, [ %fp + -8 ]                                         
  }                                                                                       
                                                                                          
  /* Check parameter */                                                                   
  if (format == NULL || pt == NULL) {                                                     
40002300:   80 a6 60 00     cmp  %i1, 0                                                   
40002304:   02 80 00 4e     be  4000243c <rtems_bdpart_write+0x184>                       <== NEVER TAKEN
40002308:   80 a6 a0 00     cmp  %i2, 0                                                   
4000230c:   02 80 00 4c     be  4000243c <rtems_bdpart_write+0x184>                       <== NEVER TAKEN
40002310:   96 07 bf f4     add  %fp, -12, %o3                                            
    return RTEMS_INVALID_ADDRESS;                                                         
  }                                                                                       
                                                                                          
  /* Get disk data */                                                                     
  sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);                       
40002314:   94 07 bf fc     add  %fp, -4, %o2                                             
40002318:   92 07 bf f8     add  %fp, -8, %o1                                             
4000231c:   7f ff fe 74     call  40001cec <rtems_bdpart_get_disk_data>                   
40002320:   90 10 00 18     mov  %i0, %o0                                                 
  if (sc != RTEMS_SUCCESSFUL) {                                                           
40002324:   ba 92 20 00     orcc  %o0, 0, %i5                                             
40002328:   12 80 00 3c     bne  40002418 <rtems_bdpart_write+0x160>                      <== NEVER TAKEN
4000232c:   80 a4 20 00     cmp  %l0, 0                                                   
    return sc;                                                                            
  }                                                                                       
                                                                                          
  /* Align end of disk on cylinder boundary if necessary */                               
  if (dos_compatibility) {                                                                
40002330:   12 80 00 46     bne  40002448 <rtems_bdpart_write+0x190>                      <== ALWAYS TAKEN
40002334:   c8 07 bf f4     ld  [ %fp + -12 ], %g4                                        
    dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;                               
40002338:   10 80 00 03     b  40002344 <rtems_bdpart_write+0x8c>                         
4000233c:   82 10 00 1a     mov  %i2, %g1                                                 
40002340:   ba 10 00 1c     mov  %i4, %i5                                                 
  /* Check that we have a consistent partition table */                                   
  for (i = 0; i < count; ++i) {                                                           
    const rtems_bdpart_partition *p = pt + i;                                             
                                                                                          
    /* Check that begin and end are proper within the disk */                             
    if (p->begin >= disk_end || p->end > disk_end) {                                      
40002344:   c4 00 40 00     ld  [ %g1 ], %g2                                              
40002348:   80 a0 80 04     cmp  %g2, %g4                                                 
4000234c:   3a 80 00 29     bcc,a   400023f0 <rtems_bdpart_write+0x138>                   <== NEVER TAKEN
40002350:   ba 10 20 0a     mov  0xa, %i5                                                 <== NOT EXECUTED
40002354:   c6 00 60 04     ld  [ %g1 + 4 ], %g3                                          
      esc = RTEMS_INVALID_NUMBER;                                                         
      goto cleanup;                                                                       
    }                                                                                     
                                                                                          
    /* Check that begin and end are valid */                                              
    if (p->begin >= p->end) {                                                             
40002358:   80 a0 80 03     cmp  %g2, %g3                                                 
4000235c:   1a 80 00 24     bcc  400023ec <rtems_bdpart_write+0x134>                      <== NEVER TAKEN
40002360:   80 a1 00 03     cmp  %g4, %g3                                                 
40002364:   0a 80 00 22     bcs  400023ec <rtems_bdpart_write+0x134>                      <== NEVER TAKEN
40002368:   80 a7 60 00     cmp  %i5, 0                                                   
      esc = RTEMS_INVALID_NUMBER;                                                         
      goto cleanup;                                                                       
    }                                                                                     
                                                                                          
    /* Check that partitions do not overlap */                                            
    if (i > 0 && pt [i - 1].end > p->begin) {                                             
4000236c:   02 80 00 06     be  40002384 <rtems_bdpart_write+0xcc>                        
40002370:   b8 07 60 01     add  %i5, 1, %i4                                              
40002374:   c6 00 7f d4     ld  [ %g1 + -44 ], %g3                                        
40002378:   80 a0 80 03     cmp  %g2, %g3                                                 
4000237c:   2a 80 00 1d     bcs,a   400023f0 <rtems_bdpart_write+0x138>                   <== NEVER TAKEN
40002380:   ba 10 20 0a     mov  0xa, %i5                                                 <== NOT EXECUTED
  for (i = 0; i < count; ++i) {                                                           
40002384:   80 a6 c0 1c     cmp  %i3, %i4                                                 
40002388:   12 bf ff ee     bne  40002340 <rtems_bdpart_write+0x88>                       
4000238c:   82 00 60 30     add  %g1, 0x30, %g1                                           
      goto cleanup;                                                                       
    }                                                                                     
  }                                                                                       
                                                                                          
  /* Check format */                                                                      
  if (format->type != RTEMS_BDPART_FORMAT_MBR) {                                          
40002390:   c2 06 40 00     ld  [ %i1 ], %g1                                              
40002394:   80 a0 60 00     cmp  %g1, 0                                                   
40002398:   12 80 00 3b     bne  40002484 <rtems_bdpart_write+0x1cc>                      <== NEVER TAKEN
4000239c:   80 a6 e0 04     cmp  %i3, 4                                                   
   * Set primary partition count.  If we have more than four partitions we need           
   * an extended partition which will contain the partitions of number four and           
   * above as logical partitions.  If we have four or less partitions we can              
   * use the primary partition table.                                                     
   */                                                                                     
  ppc = count <= 4 ? count : 3;                                                           
400023a0:   08 80 00 3b     bleu  4000248c <rtems_bdpart_write+0x1d4>                     <== NEVER TAKEN
400023a4:   80 a4 20 00     cmp  %l0, 0                                                   
                                                                                          
  /*                                                                                      
   * Check that the first primary partition starts at head one and sector one             
   * under the virtual one head and 63 sectors geometry if necessary.                     
   */                                                                                     
  if (dos_compatibility && pt [0].begin != RTEMS_BDPART_MBR_CYLINDER_SIZE) {              
400023a8:   32 80 00 e7     bne,a   40002744 <rtems_bdpart_write+0x48c>                   <== ALWAYS TAKEN
400023ac:   c2 06 80 00     ld  [ %i2 ], %g1                                              
400023b0:   89 2f 20 01     sll  %i4, 1, %g4                                              <== NOT EXECUTED
400023b4:   82 06 a0 90     add  %i2, 0x90, %g1                                           
400023b8:   88 01 00 1c     add  %g4, %i4, %g4                                            
400023bc:   b7 29 20 04     sll  %g4, 4, %i3                                              
400023c0:   10 80 00 05     b  400023d4 <rtems_bdpart_write+0x11c>                        
400023c4:   b6 06 80 1b     add  %i2, %i3, %i3                                            
   * Each logical partition is described via one EBR preceding the partition.             
   * The space for the EBR and maybe some space which is needed for DOS                   
   * compatibility resides between the partitions.  So there have to be gaps of           
   * the appropriate size between the partitions.                                         
   */                                                                                     
  for (i = ppc; i < count; ++i) {                                                         
400023c8:   80 a0 40 1b     cmp  %g1, %i3                                                 
400023cc:   02 80 00 38     be  400024ac <rtems_bdpart_write+0x1f4>                       
400023d0:   a0 10 20 03     mov  3, %l0                                                   
    if ((pt [i].begin - pt [i - 1].end) < record_space) {                                 
400023d4:   c4 00 40 00     ld  [ %g1 ], %g2                                              
400023d8:   c6 00 7f d4     ld  [ %g1 + -44 ], %g3                                        
400023dc:   84 20 80 03     sub  %g2, %g3, %g2                                            
400023e0:   80 a0 80 11     cmp  %g2, %l1                                                 
400023e4:   3a bf ff f9     bcc,a   400023c8 <rtems_bdpart_write+0x110>                   <== ALWAYS TAKEN
400023e8:   82 00 60 30     add  %g1, 0x30, %g1                                           
      esc = RTEMS_INVALID_NUMBER;                                                         
400023ec:   ba 10 20 0a     mov  0xa, %i5                                                 <== NOT EXECUTED
    }                                                                                     
  }                                                                                       
                                                                                          
cleanup:                                                                                  
                                                                                          
  if (fd >= 0) {                                                                          
400023f0:   d0 07 bf f8     ld  [ %fp + -8 ], %o0                                         
400023f4:   80 a2 20 00     cmp  %o0, 0                                                   
400023f8:   16 80 00 1c     bge  40002468 <rtems_bdpart_write+0x1b0>                      <== ALWAYS TAKEN
400023fc:   01 00 00 00     nop                                                           
    close( fd);                                                                           
  }                                                                                       
                                                                                          
  if (block != NULL) {                                                                    
40002400:   d0 07 bf f0     ld  [ %fp + -16 ], %o0                                        <== NOT EXECUTED
40002404:   80 a2 20 00     cmp  %o0, 0                                                   <== NOT EXECUTED
40002408:   02 80 00 04     be  40002418 <rtems_bdpart_write+0x160>                       <== NOT EXECUTED
4000240c:   01 00 00 00     nop                                                           <== NOT EXECUTED
    rtems_bdbuf_sync( block);                                                             
40002410:   40 00 33 92     call  4000f258 <rtems_bdbuf_sync>                             
40002414:   01 00 00 00     nop                                                           
  }                                                                                       
                                                                                          
  return esc;                                                                             
}                                                                                         
40002418:   81 c7 e0 08     ret                                                           
4000241c:   91 e8 00 1d     restore  %g0, %i5, %o0                                        
    && format->mbr.dos_compatibility;                                                     
40002420:   80 a0 60 00     cmp  %g1, 0                                                   
40002424:   02 bf ff ae     be  400022dc <rtems_bdpart_write+0x24>                        <== NEVER TAKEN
40002428:   c0 27 bf f0     clr  [ %fp + -16 ]                                            
4000242c:   a0 10 20 01     mov  1, %l0                                                   
  rtems_blkdev_bnum disk_end = 0;                                                         
40002430:   c0 27 bf f4     clr  [ %fp + -12 ]                                            
    dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;                               
40002434:   10 bf ff ad     b  400022e8 <rtems_bdpart_write+0x30>                         
40002438:   a2 10 20 3f     mov  0x3f, %l1                                                
    return RTEMS_INVALID_ADDRESS;                                                         
4000243c:   ba 10 20 09     mov  9, %i5                                                   <== NOT EXECUTED
}                                                                                         
40002440:   81 c7 e0 08     ret                                                           <== NOT EXECUTED
40002444:   91 e8 00 1d     restore  %g0, %i5, %o0                                        <== NOT EXECUTED
    disk_end -= (disk_end % record_space);                                                
40002448:   81 80 20 00     wr  %g0, %y                                                   
4000244c:   01 00 00 00     nop                                                           
40002450:   01 00 00 00     nop                                                           
40002454:   01 00 00 00     nop                                                           
40002458:   88 71 00 11     udiv  %g4, %l1, %g4                                           
4000245c:   88 59 00 11     smul  %g4, %l1, %g4                                           
40002460:   10 bf ff b6     b  40002338 <rtems_bdpart_write+0x80>                         
40002464:   c8 27 bf f4     st  %g4, [ %fp + -12 ]                                        
    close( fd);                                                                           
40002468:   40 00 05 2d     call  4000391c <close>                                        
4000246c:   01 00 00 00     nop                                                           
  if (block != NULL) {                                                                    
40002470:   d0 07 bf f0     ld  [ %fp + -16 ], %o0                                        
40002474:   80 a2 20 00     cmp  %o0, 0                                                   
40002478:   12 bf ff e6     bne  40002410 <rtems_bdpart_write+0x158>                      <== ALWAYS TAKEN
4000247c:   01 00 00 00     nop                                                           
40002480:   30 bf ff e6     b,a   40002418 <rtems_bdpart_write+0x160>                     <== NOT EXECUTED
    esc = RTEMS_NOT_IMPLEMENTED;                                                          
40002484:   10 bf ff db     b  400023f0 <rtems_bdpart_write+0x138>                        <== NOT EXECUTED
40002488:   ba 10 20 18     mov  0x18, %i5                                                <== NOT EXECUTED
  if (dos_compatibility && pt [0].begin != RTEMS_BDPART_MBR_CYLINDER_SIZE) {              
4000248c:   22 80 00 07     be,a   400024a8 <rtems_bdpart_write+0x1f0>                    <== NOT EXECUTED
40002490:   a0 10 00 1c     mov  %i4, %l0                                                 <== NOT EXECUTED
40002494:   c2 06 80 00     ld  [ %i2 ], %g1                                              <== NOT EXECUTED
40002498:   80 a0 60 3f     cmp  %g1, 0x3f                                                <== NOT EXECUTED
4000249c:   32 bf ff d5     bne,a   400023f0 <rtems_bdpart_write+0x138>                   <== NOT EXECUTED
400024a0:   ba 10 20 0a     mov  0xa, %i5                                                 <== NOT EXECUTED
400024a4:   a0 10 00 1c     mov  %i4, %l0                                                 <== NOT EXECUTED
400024a8:   88 5f 20 03     smul  %i4, 3, %g4                                             <== NOT EXECUTED
400024ac:   b6 06 a0 08     add  %i2, 8, %i3                                              
400024b0:   89 29 20 04     sll  %g4, 4, %g4                                              
400024b4:   b0 06 c0 04     add  %i3, %g4, %i0                                            
    uint8_t type = 0;                                                                     
400024b8:   c0 2f bf ef     clrb  [ %fp + -17 ]                                           
    if (!rtems_bdpart_to_mbr_partition_type( p->type, &type)) {                           
400024bc:   90 10 00 1b     mov  %i3, %o0                                                 
400024c0:   7f ff fd ff     call  40001cbc <rtems_bdpart_to_mbr_partition_type>           
400024c4:   92 07 bf ef     add  %fp, -17, %o1                                            
400024c8:   80 a2 20 00     cmp  %o0, 0                                                   
400024cc:   22 bf ff c9     be,a   400023f0 <rtems_bdpart_write+0x138>                    <== NEVER TAKEN
400024d0:   ba 10 20 04     mov  4, %i5                                                   <== NOT EXECUTED
    if (p->flags > 0xffU) {                                                               
400024d4:   c2 06 e0 20     ld  [ %i3 + 0x20 ], %g1                                       
400024d8:   80 a0 60 00     cmp  %g1, 0                                                   
400024dc:   32 bf ff c5     bne,a   400023f0 <rtems_bdpart_write+0x138>                   <== NEVER TAKEN
400024e0:   ba 10 20 04     mov  4, %i5                                                   <== NOT EXECUTED
400024e4:   c2 06 e0 24     ld  [ %i3 + 0x24 ], %g1                                       
400024e8:   80 a0 60 ff     cmp  %g1, 0xff                                                
400024ec:   38 bf ff c1     bgu,a   400023f0 <rtems_bdpart_write+0x138>                   <== NEVER TAKEN
400024f0:   ba 10 20 04     mov  4, %i5                                                   <== NOT EXECUTED
  for (i = 0; i < count; ++i) {                                                           
400024f4:   b6 06 e0 30     add  %i3, 0x30, %i3                                           
400024f8:   80 a6 c0 18     cmp  %i3, %i0                                                 
400024fc:   32 bf ff f0     bne,a   400024bc <rtems_bdpart_write+0x204>                   
40002500:   c0 2f bf ef     clrb  [ %fp + -17 ]                                           
  sc = rtems_bdpart_new_record( dd, 0, &block);                                           
40002504:   d0 07 bf fc     ld  [ %fp + -4 ], %o0                                         
40002508:   92 10 20 00     clr  %o1                                                      
4000250c:   7f ff ff 48     call  4000222c <rtems_bdpart_new_record>                      
40002510:   94 07 bf f0     add  %fp, -16, %o2                                            
  if (sc != RTEMS_SUCCESSFUL) {                                                           
40002514:   80 a2 20 00     cmp  %o0, 0                                                   
40002518:   32 bf ff b6     bne,a   400023f0 <rtems_bdpart_write+0x138>                   <== NEVER TAKEN
4000251c:   ba 10 00 08     mov  %o0, %i5                                                 <== NOT EXECUTED
    block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID                                       
40002520:   c8 07 bf f0     ld  [ %fp + -16 ], %g4                                        
  rtems_uint32_to_little_endian(                                                          
40002524:   c2 06 60 04     ld  [ %i1 + 4 ], %g1                                          
    block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID                                       
40002528:   c6 01 20 1c     ld  [ %g4 + 0x1c ], %g3                                       
{                                                                                         
  int i;                                                                                  
                                                                                          
  for (i = 0; i < 4; ++i) {                                                               
    data [i] = (uint8_t) value;                                                           
    value >>= 8;                                                                          
4000252c:   85 30 60 10     srl  %g1, 0x10, %g2                                           
    data [i] = (uint8_t) value;                                                           
40002530:   c2 28 e1 b8     stb  %g1, [ %g3 + 0x1b8 ]                                     
    value >>= 8;                                                                          
40002534:   b7 30 60 08     srl  %g1, 8, %i3                                              
    data [i] = (uint8_t) value;                                                           
40002538:   c4 28 e1 ba     stb  %g2, [ %g3 + 0x1ba ]                                     
    value >>= 8;                                                                          
4000253c:   83 30 60 18     srl  %g1, 0x18, %g1                                           
    data [i] = (uint8_t) value;                                                           
40002540:   f6 28 e1 b9     stb  %i3, [ %g3 + 0x1b9 ]                                     
40002544:   85 2c 20 04     sll  %l0, 4, %g2                                              
40002548:   c2 28 e1 bb     stb  %g1, [ %g3 + 0x1bb ]                                     
  data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;                                 
4000254c:   84 00 a1 be     add  %g2, 0x1be, %g2                                          
40002550:   da 01 20 1c     ld  [ %g4 + 0x1c ], %o5                                       
40002554:   82 03 61 be     add  %o5, 0x1be, %g1                                          
40002558:   88 10 00 1a     mov  %i2, %g4                                                 
4000255c:   9a 03 40 02     add  %o5, %g2, %o5                                            
    rtems_bdpart_write_mbr_partition(                                                     
40002560:   c6 01 00 00     ld  [ %g4 ], %g3                                              
40002564:   c4 01 20 04     ld  [ %g4 + 4 ], %g2                                          
40002568:   f2 09 20 08     ldub  [ %g4 + 8 ], %i1                                        
4000256c:   f6 01 20 2c     ld  [ %g4 + 0x2c ], %i3                                       
40002570:   84 20 80 03     sub  %g2, %g3, %g2                                            
40002574:   c6 28 60 08     stb  %g3, [ %g1 + 8 ]                                         
    value >>= 8;                                                                          
40002578:   b1 30 e0 10     srl  %g3, 0x10, %i0                                           
4000257c:   9f 30 e0 08     srl  %g3, 8, %o7                                              
40002580:   87 30 e0 18     srl  %g3, 0x18, %g3                                           
    data [i] = (uint8_t) value;                                                           
40002584:   c4 28 60 0c     stb  %g2, [ %g1 + 0xc ]                                       
    data += RTEMS_BDPART_MBR_TABLE_ENTRY_SIZE;                                            
40002588:   82 00 60 10     add  %g1, 0x10, %g1                                           
4000258c:   f0 28 7f fa     stb  %i0, [ %g1 + -6 ]                                        
    value >>= 8;                                                                          
40002590:   b1 30 a0 08     srl  %g2, 8, %i0                                              
    data [i] = (uint8_t) value;                                                           
40002594:   c6 28 7f fb     stb  %g3, [ %g1 + -5 ]                                        
    value >>= 8;                                                                          
40002598:   87 30 a0 10     srl  %g2, 0x10, %g3                                           
    data [i] = (uint8_t) value;                                                           
4000259c:   de 28 7f f9     stb  %o7, [ %g1 + -7 ]                                        
    value >>= 8;                                                                          
400025a0:   85 30 a0 18     srl  %g2, 0x18, %g2                                           
    data [i] = (uint8_t) value;                                                           
400025a4:   f0 28 7f fd     stb  %i0, [ %g1 + -3 ]                                        
  for (i = 0; i < ppc; ++i) {                                                             
400025a8:   88 01 20 30     add  %g4, 0x30, %g4                                           
400025ac:   c6 28 7f fe     stb  %g3, [ %g1 + -2 ]                                        
400025b0:   c4 28 7f ff     stb  %g2, [ %g1 + -1 ]                                        
400025b4:   80 a0 40 0d     cmp  %g1, %o5                                                 
  data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;                                             
400025b8:   f2 28 7f f4     stb  %i1, [ %g1 + -12 ]                                       
  for (i = 0; i < ppc; ++i) {                                                             
400025bc:   12 bf ff e9     bne  40002560 <rtems_bdpart_write+0x2a8>                      
400025c0:   f6 28 7f f0     stb  %i3, [ %g1 + -16 ]                                       
  if (ppc != count) {                                                                     
400025c4:   80 a7 00 10     cmp  %i4, %l0                                                 
400025c8:   22 bf ff 8a     be,a   400023f0 <rtems_bdpart_write+0x138>                    <== NEVER TAKEN
400025cc:   ba 10 20 00     clr  %i5                                                      <== NOT EXECUTED
    rtems_bdpart_write_mbr_partition(                                                     
400025d0:   c4 07 bf f4     ld  [ %fp + -12 ], %g2                                        
    rtems_blkdev_bnum ep_begin = pt [ppc].begin - record_space;                           
400025d4:   87 2c 20 01     sll  %l0, 1, %g3                                              
400025d8:   86 00 c0 10     add  %g3, %l0, %g3                                            
400025dc:   87 28 e0 04     sll  %g3, 4, %g3                                              
400025e0:   f6 06 80 03     ld  [ %i2 + %g3 ], %i3                                        
    rtems_bdpart_write_mbr_partition(                                                     
400025e4:   84 04 40 02     add  %l1, %g2, %g2                                            
400025e8:   84 20 80 1b     sub  %g2, %i3, %g2                                            
    rtems_blkdev_bnum ep_begin = pt [ppc].begin - record_space;                           
400025ec:   88 26 c0 11     sub  %i3, %l1, %g4                                            
    value >>= 8;                                                                          
400025f0:   9f 30 a0 08     srl  %g2, 8, %o7                                              
400025f4:   b1 30 a0 10     srl  %g2, 0x10, %i0                                           
400025f8:   b3 30 a0 18     srl  %g2, 0x18, %i1                                           
    data [i] = (uint8_t) value;                                                           
400025fc:   c4 28 60 0c     stb  %g2, [ %g1 + 0xc ]                                       
    value >>= 8;                                                                          
40002600:   97 31 20 08     srl  %g4, 8, %o3                                              
40002604:   99 31 20 10     srl  %g4, 0x10, %o4                                           
40002608:   9b 31 20 18     srl  %g4, 0x18, %o5                                           
  data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;                                             
4000260c:   84 10 20 05     mov  5, %g2                                                   
    data [i] = (uint8_t) value;                                                           
40002610:   c8 28 60 08     stb  %g4, [ %g1 + 8 ]                                         
    rtems_blkdev_bnum ep_begin = pt [ppc].begin - record_space;                           
40002614:   b8 06 80 03     add  %i2, %g3, %i4                                            
40002618:   d6 28 60 09     stb  %o3, [ %g1 + 9 ]                                         
4000261c:   d8 28 60 0a     stb  %o4, [ %g1 + 0xa ]                                       
40002620:   da 28 60 0b     stb  %o5, [ %g1 + 0xb ]                                       
40002624:   de 28 60 0d     stb  %o7, [ %g1 + 0xd ]                                       
40002628:   f0 28 60 0e     stb  %i0, [ %g1 + 0xe ]                                       
4000262c:   f2 28 60 0f     stb  %i1, [ %g1 + 0xf ]                                       
  data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;                                             
40002630:   c4 28 60 04     stb  %g2, [ %g1 + 4 ]                                         
    for (i = ppc; i < count; ++i) {                                                       
40002634:   08 80 00 40     bleu  40002734 <rtems_bdpart_write+0x47c>                     <== NEVER TAKEN
40002638:   c0 28 40 00     clrb  [ %g1 ]                                                 
      ebr = p->begin - record_space;                                                      
4000263c:   d2 06 80 03     ld  [ %i2 + %g3 ], %o1                                        
40002640:   b0 10 00 1c     mov  %i4, %i0                                                 
40002644:   b2 10 00 10     mov  %l0, %i1                                                 
  data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;                                             
40002648:   b4 10 20 05     mov  5, %i2                                                   
      sc = rtems_bdpart_new_record( dd, ebr, &block);                                     
4000264c:   d0 07 bf fc     ld  [ %fp + -4 ], %o0                                         
40002650:   92 22 40 11     sub  %o1, %l1, %o1                                            
40002654:   7f ff fe f6     call  4000222c <rtems_bdpart_new_record>                      
40002658:   94 07 bf f0     add  %fp, -16, %o2                                            
      if (sc != RTEMS_SUCCESSFUL) {                                                       
4000265c:   80 a2 20 00     cmp  %o0, 0                                                   
40002660:   12 80 00 37     bne  4000273c <rtems_bdpart_write+0x484>                      <== NEVER TAKEN
40002664:   80 a6 40 1d     cmp  %i1, %i5                                                 
        block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,                                  
40002668:   c8 07 bf f0     ld  [ %fp + -16 ], %g4                                        
      rtems_bdpart_write_mbr_partition(                                                   
4000266c:   c6 07 00 00     ld  [ %i4 ], %g3                                              
40002670:   c4 07 20 04     ld  [ %i4 + 4 ], %g2                                          
40002674:   da 0f 20 08     ldub  [ %i4 + 8 ], %o5                                        
40002678:   de 07 20 2c     ld  [ %i4 + 0x2c ], %o7                                       
        block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,                                  
4000267c:   c2 01 20 1c     ld  [ %g4 + 0x1c ], %g1                                       
      rtems_bdpart_write_mbr_partition(                                                   
40002680:   84 20 80 03     sub  %g2, %g3, %g2                                            
40002684:   e2 28 61 c6     stb  %l1, [ %g1 + 0x1c6 ]                                     
    value >>= 8;                                                                          
40002688:   95 30 a0 08     srl  %g2, 8, %o2                                              
4000268c:   97 30 a0 10     srl  %g2, 0x10, %o3                                           
40002690:   99 30 a0 18     srl  %g2, 0x18, %o4                                           
    data [i] = (uint8_t) value;                                                           
40002694:   c0 28 61 c7     clrb  [ %g1 + 0x1c7 ]                                         
    for (i = ppc; i < count; ++i) {                                                       
40002698:   86 06 60 01     add  %i1, 1, %g3                                              
4000269c:   c0 28 61 c8     clrb  [ %g1 + 0x1c8 ]                                         
400026a0:   c0 28 61 c9     clrb  [ %g1 + 0x1c9 ]                                         
400026a4:   b8 07 20 30     add  %i4, 0x30, %i4                                           
400026a8:   c4 28 61 ca     stb  %g2, [ %g1 + 0x1ca ]                                     
  data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;                                 
400026ac:   b2 10 00 03     mov  %g3, %i1                                                 
400026b0:   d4 28 61 cb     stb  %o2, [ %g1 + 0x1cb ]                                     
400026b4:   d6 28 61 cc     stb  %o3, [ %g1 + 0x1cc ]                                     
400026b8:   d8 28 61 cd     stb  %o4, [ %g1 + 0x1cd ]                                     
  data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;                                             
400026bc:   da 28 61 c2     stb  %o5, [ %g1 + 0x1c2 ]                                     
    for (i = ppc; i < count; ++i) {                                                       
400026c0:   02 80 00 1d     be  40002734 <rtems_bdpart_write+0x47c>                       
400026c4:   de 28 61 be     stb  %o7, [ %g1 + 0x1be ]                                     
        rtems_blkdev_bnum begin = p->begin - record_space;                                
400026c8:   d2 06 20 30     ld  [ %i0 + 0x30 ], %o1                                       
        rtems_bdpart_write_mbr_partition(                                                 
400026cc:   84 22 40 1b     sub  %o1, %i3, %g2                                            
      if (i > ppc) {                                                                      
400026d0:   80 a0 c0 10     cmp  %g3, %l0                                                 
    value >>= 8;                                                                          
400026d4:   99 30 a0 08     srl  %g2, 8, %o4                                              
400026d8:   9b 30 a0 10     srl  %g2, 0x10, %o5                                           
400026dc:   08 80 00 14     bleu  4000272c <rtems_bdpart_write+0x474>                     <== NEVER TAKEN
400026e0:   9f 30 a0 18     srl  %g2, 0x18, %o7                                           
          block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1,                                
400026e4:   c2 01 20 1c     ld  [ %g4 + 0x1c ], %g1                                       
    data [i] = (uint8_t) value;                                                           
400026e8:   c4 28 61 d6     stb  %g2, [ %g1 + 0x1d6 ]                                     
        rtems_bdpart_write_mbr_partition(                                                 
400026ec:   c4 07 bf f4     ld  [ %fp + -12 ], %g2                                        
400026f0:   d8 28 61 d7     stb  %o4, [ %g1 + 0x1d7 ]                                     
400026f4:   84 04 40 02     add  %l1, %g2, %g2                                            
400026f8:   da 28 61 d8     stb  %o5, [ %g1 + 0x1d8 ]                                     
400026fc:   84 20 80 09     sub  %g2, %o1, %g2                                            
40002700:   de 28 61 d9     stb  %o7, [ %g1 + 0x1d9 ]                                     
    value >>= 8;                                                                          
40002704:   89 30 a0 08     srl  %g2, 8, %g4                                              
    data [i] = (uint8_t) value;                                                           
40002708:   c4 28 61 da     stb  %g2, [ %g1 + 0x1da ]                                     
    value >>= 8;                                                                          
4000270c:   87 30 a0 10     srl  %g2, 0x10, %g3                                           
    data [i] = (uint8_t) value;                                                           
40002710:   c8 28 61 db     stb  %g4, [ %g1 + 0x1db ]                                     
    value >>= 8;                                                                          
40002714:   85 30 a0 18     srl  %g2, 0x18, %g2                                           
    data [i] = (uint8_t) value;                                                           
40002718:   c6 28 61 dc     stb  %g3, [ %g1 + 0x1dc ]                                     
4000271c:   c4 28 61 dd     stb  %g2, [ %g1 + 0x1dd ]                                     
  data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;                                             
40002720:   f4 28 61 d2     stb  %i2, [ %g1 + 0x1d2 ]                                     
  data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;                                           
40002724:   c0 28 61 ce     clrb  [ %g1 + 0x1ce ]                                         
      ebr = p->begin - record_space;                                                      
40002728:   d2 06 20 30     ld  [ %i0 + 0x30 ], %o1                                       
4000272c:   10 bf ff c8     b  4000264c <rtems_bdpart_write+0x394>                        
40002730:   b0 06 20 30     add  %i0, 0x30, %i0                                           
  rtems_status_code esc = RTEMS_SUCCESSFUL;                                               
40002734:   10 bf ff 2f     b  400023f0 <rtems_bdpart_write+0x138>                        
40002738:   ba 10 20 00     clr  %i5                                                      
4000273c:   10 bf ff 2d     b  400023f0 <rtems_bdpart_write+0x138>                        <== NOT EXECUTED
40002740:   ba 10 00 08     mov  %o0, %i5                                                 <== NOT EXECUTED
  if (dos_compatibility && pt [0].begin != RTEMS_BDPART_MBR_CYLINDER_SIZE) {              
40002744:   80 a0 60 3f     cmp  %g1, 0x3f                                                
40002748:   22 bf ff 1b     be,a   400023b4 <rtems_bdpart_write+0xfc>                     <== ALWAYS TAKEN
4000274c:   89 2f 20 01     sll  %i4, 1, %g4                                              
      esc = RTEMS_INVALID_NUMBER;                                                         
40002750:   10 bf ff 28     b  400023f0 <rtems_bdpart_write+0x138>                        <== NOT EXECUTED
40002754:   ba 10 20 0a     mov  0xa, %i5                                                 <== NOT EXECUTED
                                                                                          
===============================================================================
40002b64 <rtems_blkdev_create_partition>:                                                 
  const char *partition,                                                                  
  const char *parent_block_device,                                                        
  rtems_blkdev_bnum media_block_begin,                                                    
  rtems_blkdev_bnum media_block_count                                                     
)                                                                                         
{                                                                                         
40002b64:   9d e3 bf 30     save  %sp, -208, %sp                                          
  rtems_status_code sc = RTEMS_SUCCESSFUL;                                                
  int fd = open(parent_block_device, O_RDWR);                                             
40002b68:   92 10 20 02     mov  2, %o1                                                   
40002b6c:   90 10 00 19     mov  %i1, %o0                                                 
40002b70:   40 00 06 f8     call  40004750 <open>                                         
40002b74:   b8 10 20 04     mov  4, %i4                                                   
                                                                                          
  if (fd >= 0) {                                                                          
40002b78:   80 a2 20 00     cmp  %o0, 0                                                   
40002b7c:   06 80 00 0f     bl  40002bb8 <rtems_blkdev_create_partition+0x54>             
40002b80:   ba 10 00 08     mov  %o0, %i5                                                 
    int rv;                                                                               
    struct stat st;                                                                       
                                                                                          
    rv = fstat(fd, &st);                                                                  
40002b84:   40 00 04 02     call  40003b8c <fstat>                                        
40002b88:   92 07 bf 98     add  %fp, -104, %o1                                           
    if (rv == 0 && S_ISBLK(st.st_mode)) {                                                 
40002b8c:   80 a2 20 00     cmp  %o0, 0                                                   
40002b90:   12 80 00 0c     bne  40002bc0 <rtems_blkdev_create_partition+0x5c>            <== NEVER TAKEN
40002b94:   03 00 00 3c     sethi  %hi(0xf000), %g1                                       
40002b98:   f2 07 bf a8     ld  [ %fp + -88 ], %i1                                        
40002b9c:   b2 0e 40 01     and  %i1, %g1, %i1                                            
40002ba0:   03 00 00 18     sethi  %hi(0x6000), %g1                                       
40002ba4:   80 a6 40 01     cmp  %i1, %g1                                                 
40002ba8:   02 80 00 08     be  40002bc8 <rtems_blkdev_create_partition+0x64>             
40002bac:   b8 10 20 15     mov  0x15, %i4                                                
    } else {                                                                              
      sc = RTEMS_INVALID_NODE;                                                            
    }                                                                                     
                                                                                          
    if (sc != RTEMS_SUCCESSFUL) {                                                         
      close(fd);                                                                          
40002bb0:   40 00 03 5b     call  4000391c <close>                                        
40002bb4:   90 10 00 1d     mov  %i5, %o0                                                 
  } else {                                                                                
    sc = RTEMS_INVALID_ID;                                                                
  }                                                                                       
                                                                                          
  return sc;                                                                              
}                                                                                         
40002bb8:   81 c7 e0 08     ret                                                           
40002bbc:   91 e8 00 1c     restore  %g0, %i4, %o0                                        
      sc = RTEMS_INVALID_NODE;                                                            
40002bc0:   10 bf ff fc     b  40002bb0 <rtems_blkdev_create_partition+0x4c>              <== NOT EXECUTED
40002bc4:   b8 10 20 15     mov  0x15, %i4                                                <== NOT EXECUTED
40002bc8:   94 07 bf 94     add  %fp, -108, %o2                                           
40002bcc:   90 10 00 1d     mov  %i5, %o0                                                 
40002bd0:   13 10 01 10     sethi  %hi(0x40044000), %o1                                   
        sc = RTEMS_NOT_IMPLEMENTED;                                                       
40002bd4:   b8 10 20 18     mov  0x18, %i4                                                
40002bd8:   40 00 04 38     call  40003cb8 <ioctl>                                        
40002bdc:   92 12 62 09     or  %o1, 0x209, %o1                                           
      if (rv == 0) {                                                                      
40002be0:   80 a2 20 00     cmp  %o0, 0                                                   
40002be4:   12 bf ff f3     bne  40002bb0 <rtems_blkdev_create_partition+0x4c>            
40002be8:   90 10 20 80     mov  0x80, %o0                                                
        rtems_blkdev_imfs_context *ctx = malloc(sizeof(*ctx));                            
40002bec:   40 00 04 fd     call  40003fe0 <malloc>                                       
40002bf0:   b8 10 20 1a     mov  0x1a, %i4                                                
        if (ctx != NULL) {                                                                
40002bf4:   a0 92 20 00     orcc  %o0, 0, %l0                                             
40002bf8:   02 bf ff ee     be  40002bb0 <rtems_blkdev_create_partition+0x4c>             
40002bfc:   d2 07 bf 94     ld  [ %fp + -108 ], %o1                                       
          sc = rtems_disk_init_log(                                                       
40002c00:   96 10 00 1b     mov  %i3, %o3                                                 
40002c04:   40 00 00 2e     call  40002cbc <rtems_disk_init_log>                          
40002c08:   94 10 00 1a     mov  %i2, %o2                                                 
          if (sc == RTEMS_SUCCESSFUL) {                                                   
40002c0c:   b8 92 20 00     orcc  %o0, 0, %i4                                             
40002c10:   12 80 00 0e     bne  40002c48 <rtems_blkdev_create_partition+0xe4>            
40002c14:   96 10 00 10     mov  %l0, %o3                                                 
            ctx->fd = fd;                                                                 
40002c18:   fa 24 20 78     st  %i5, [ %l0 + 0x78 ]                                       
            rv = IMFS_make_generic_node(                                                  
40002c1c:   92 16 61 ff     or  %i1, 0x1ff, %o1                                           
40002c20:   15 10 00 7d     sethi  %hi(0x4001f400), %o2                                   
40002c24:   90 10 00 18     mov  %i0, %o0                                                 
40002c28:   40 00 0f 0a     call  40006850 <IMFS_make_generic_node>                       
40002c2c:   94 12 a3 ec     or  %o2, 0x3ec, %o2                                           
            if (rv != 0) {                                                                
40002c30:   80 a2 20 00     cmp  %o0, 0                                                   
40002c34:   02 bf ff e1     be  40002bb8 <rtems_blkdev_create_partition+0x54>             
40002c38:   90 10 00 10     mov  %l0, %o0                                                 
              free(ctx);                                                                  
40002c3c:   40 00 03 9a     call  40003aa4 <free>                                         
40002c40:   b8 10 20 0d     mov  0xd, %i4                                                 
    if (sc != RTEMS_SUCCESSFUL) {                                                         
40002c44:   30 bf ff db     b,a   40002bb0 <rtems_blkdev_create_partition+0x4c>           
            free(ctx);                                                                    
40002c48:   40 00 03 97     call  40003aa4 <free>                                         
40002c4c:   90 10 00 10     mov  %l0, %o0                                                 
    if (sc != RTEMS_SUCCESSFUL) {                                                         
40002c50:   30 bf ff d8     b,a   40002bb0 <rtems_blkdev_create_partition+0x4c>           
                                                                                          
===============================================================================
40001d1c <rtems_blkdev_generic_ioctl>:                                                    
rtems_device_driver                                                                       
rtems_blkdev_generic_ioctl(                                                               
    rtems_device_major_number major RTEMS_UNUSED,                                         
    rtems_device_minor_number minor RTEMS_UNUSED,                                         
    void                    * arg)                                                        
{                                                                                         
40001d1c:   9d e3 bf a0     save  %sp, -96, %sp                                           
    rtems_libio_ioctl_args_t *args = arg;                                                 
    rtems_libio_t *iop = args->iop;                                                       
    rtems_disk_device *dd = iop->data1;                                                   
                                                                                          
    if (args->command != RTEMS_BLKIO_REQUEST)                                             
40001d20:   d2 06 a0 04     ld  [ %i2 + 4 ], %o1                                          
40001d24:   03 30 06 10     sethi  %hi(0xc0184000), %g1                                   
40001d28:   82 10 62 01     or  %g1, 0x201, %g1 ! c0184201 <RAM_END+0x7fd84201>           
40001d2c:   80 a2 40 01     cmp  %o1, %g1                                                 
40001d30:   02 80 00 0a     be  40001d58 <rtems_blkdev_generic_ioctl+0x3c>                <== NEVER TAKEN
40001d34:   82 10 3f ff     mov  -1, %g1                                                  
    rtems_disk_device *dd = iop->data1;                                                   
40001d38:   c2 06 80 00     ld  [ %i2 ], %g1                                              
40001d3c:   d0 00 60 2c     ld  [ %g1 + 0x2c ], %o0                                       
    {                                                                                     
        args->ioctl_return = dd->ioctl(dd,                                                
40001d40:   c2 02 20 38     ld  [ %o0 + 0x38 ], %g1                                       
40001d44:   9f c0 40 00     call  %g1                                                     
40001d48:   d4 06 a0 08     ld  [ %i2 + 8 ], %o2                                          
40001d4c:   d0 26 a0 0c     st  %o0, [ %i2 + 0xc ]                                        
         */                                                                               
        args->ioctl_return = -1;                                                          
    }                                                                                     
                                                                                          
    return RTEMS_SUCCESSFUL;                                                              
}                                                                                         
40001d50:   81 c7 e0 08     ret                                                           
40001d54:   91 e8 20 00     restore  %g0, 0, %o0                                          
        args->ioctl_return = -1;                                                          
40001d58:   c2 26 a0 0c     st  %g1, [ %i2 + 0xc ]                                        <== NOT EXECUTED
}                                                                                         
40001d5c:   81 c7 e0 08     ret                                                           <== NOT EXECUTED
40001d60:   91 e8 20 00     restore  %g0, 0, %o0                                          <== NOT EXECUTED
                                                                                          
===============================================================================
40001ad4 <rtems_blkdev_generic_read>:                                                     
rtems_device_driver                                                                       
rtems_blkdev_generic_read(                                                                
    rtems_device_major_number major RTEMS_UNUSED,                                         
    rtems_device_minor_number minor RTEMS_UNUSED,                                         
    void                    * arg)                                                        
{                                                                                         
40001ad4:   9d e3 bf 98     save  %sp, -104, %sp                                          <== NOT EXECUTED
    rtems_status_code rc = RTEMS_SUCCESSFUL;                                              
    rtems_libio_rw_args_t *args = arg;                                                    
    rtems_libio_t *iop = args->iop;                                                       
    rtems_disk_device *dd = iop->data1;                                                   
40001ad8:   c2 06 80 00     ld  [ %i2 ], %g1                                              <== NOT EXECUTED
40001adc:   e4 00 60 2c     ld  [ %g1 + 0x2c ], %l2                                       <== NOT EXECUTED
    uint32_t block_size = dd->block_size;                                                 
    char *buf = args->buffer;                                                             
    uint32_t count = args->count;                                                         
    rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);            
40001ae0:   f8 1e a0 08     ldd  [ %i2 + 8 ], %i4                                         <== NOT EXECUTED
    uint32_t block_size = dd->block_size;                                                 
40001ae4:   e2 04 a0 24     ld  [ %l2 + 0x24 ], %l1                                       <== NOT EXECUTED
    rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);            
40001ae8:   94 10 20 00     clr  %o2                                                      <== NOT EXECUTED
40001aec:   96 10 00 11     mov  %l1, %o3                                                 <== NOT EXECUTED
40001af0:   90 10 00 1c     mov  %i4, %o0                                                 <== NOT EXECUTED
40001af4:   40 00 3f 2d     call  400117a8 <__divdi3>                                     <== NOT EXECUTED
40001af8:   92 10 00 1d     mov  %i5, %o1                                                 <== NOT EXECUTED
    uint32_t blkofs = (uint32_t) (args->offset % block_size);                             
40001afc:   90 10 00 1c     mov  %i4, %o0                                                 <== NOT EXECUTED
40001b00:   94 10 20 00     clr  %o2                                                      <== NOT EXECUTED
    rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);            
40001b04:   b2 10 00 09     mov  %o1, %i1                                                 <== NOT EXECUTED
    uint32_t blkofs = (uint32_t) (args->offset % block_size);                             
40001b08:   96 10 00 11     mov  %l1, %o3                                                 <== NOT EXECUTED
40001b0c:   40 00 3f b2     call  400119d4 <__moddi3>                                     <== NOT EXECUTED
40001b10:   92 10 00 1d     mov  %i5, %o1                                                 <== NOT EXECUTED
                                                                                          
    args->bytes_moved = 0;                                                                
40001b14:   c0 26 a0 1c     clr  [ %i2 + 0x1c ]                                           <== NOT EXECUTED
    uint32_t blkofs = (uint32_t) (args->offset % block_size);                             
40001b18:   b8 10 00 09     mov  %o1, %i4                                                 <== NOT EXECUTED
    uint32_t count = args->count;                                                         
40001b1c:   f6 06 a0 14     ld  [ %i2 + 0x14 ], %i3                                       <== NOT EXECUTED
                                                                                          
    while (count > 0)                                                                     
40001b20:   80 a6 e0 00     cmp  %i3, 0                                                   <== NOT EXECUTED
40001b24:   12 80 00 18     bne  40001b84 <rtems_blkdev_generic_read+0xb0>                <== NOT EXECUTED
40001b28:   e0 06 a0 10     ld  [ %i2 + 0x10 ], %l0                                       <== NOT EXECUTED
        if (copy > count)                                                                 
            copy = count;                                                                 
        memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);                              
        rc = rtems_bdbuf_release(diskbuf);                                                
        args->bytes_moved += copy;                                                        
        if (rc != RTEMS_SUCCESSFUL)                                                       
40001b2c:   81 c7 e0 08     ret                                                           <== NOT EXECUTED
40001b30:   91 e8 20 00     restore  %g0, 0, %o0                                          <== NOT EXECUTED
        copy = block_size - blkofs;                                                       
40001b34:   ba 24 40 1c     sub  %l1, %i4, %i5                                            <== NOT EXECUTED
        if (copy > count)                                                                 
40001b38:   80 a7 40 1b     cmp  %i5, %i3                                                 <== NOT EXECUTED
40001b3c:   38 80 00 02     bgu,a   40001b44 <rtems_blkdev_generic_read+0x70>             <== NOT EXECUTED
40001b40:   ba 10 00 1b     mov  %i3, %i5                                                 <== NOT EXECUTED
        memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);                              
40001b44:   c2 07 bf fc     ld  [ %fp + -4 ], %g1                                         <== NOT EXECUTED
40001b48:   d2 00 60 1c     ld  [ %g1 + 0x1c ], %o1                                       <== NOT EXECUTED
40001b4c:   92 02 40 1c     add  %o1, %i4, %o1                                            <== NOT EXECUTED
40001b50:   40 00 44 87     call  40012d6c <memcpy>                                       <== NOT EXECUTED
40001b54:   94 10 00 1d     mov  %i5, %o2                                                 <== NOT EXECUTED
        rc = rtems_bdbuf_release(diskbuf);                                                
40001b58:   40 00 2a d7     call  4000c6b4 <rtems_bdbuf_release>                          <== NOT EXECUTED
40001b5c:   d0 07 bf fc     ld  [ %fp + -4 ], %o0                                         <== NOT EXECUTED
        args->bytes_moved += copy;                                                        
40001b60:   c2 06 a0 1c     ld  [ %i2 + 0x1c ], %g1                                       <== NOT EXECUTED
40001b64:   82 00 40 1d     add  %g1, %i5, %g1                                            <== NOT EXECUTED
        if (rc != RTEMS_SUCCESSFUL)                                                       
40001b68:   b8 92 20 00     orcc  %o0, 0, %i4                                             <== NOT EXECUTED
40001b6c:   12 80 00 12     bne  40001bb4 <rtems_blkdev_generic_read+0xe0>                <== NOT EXECUTED
40001b70:   c2 26 a0 1c     st  %g1, [ %i2 + 0x1c ]                                       <== NOT EXECUTED
            break;                                                                        
        count -= copy;                                                                    
        buf += copy;                                                                      
40001b74:   a0 04 00 1d     add  %l0, %i5, %l0                                            <== NOT EXECUTED
    while (count > 0)                                                                     
40001b78:   b6 a6 c0 1d     subcc  %i3, %i5, %i3                                          <== NOT EXECUTED
40001b7c:   02 80 00 0c     be  40001bac <rtems_blkdev_generic_read+0xd8>                 <== NOT EXECUTED
40001b80:   b2 06 60 01     inc  %i1                                                      <== NOT EXECUTED
        rc = rtems_bdbuf_read(dd, block, &diskbuf);                                       
40001b84:   92 10 00 19     mov  %i1, %o1                                                 <== NOT EXECUTED
40001b88:   94 07 bf fc     add  %fp, -4, %o2                                             <== NOT EXECUTED
40001b8c:   40 00 2a 42     call  4000c494 <rtems_bdbuf_read>                             <== NOT EXECUTED
40001b90:   90 10 00 12     mov  %l2, %o0                                                 <== NOT EXECUTED
40001b94:   b0 10 00 08     mov  %o0, %i0                                                 <== NOT EXECUTED
        if (rc != RTEMS_SUCCESSFUL)                                                       
40001b98:   80 a6 20 00     cmp  %i0, 0                                                   <== NOT EXECUTED
40001b9c:   02 bf ff e6     be  40001b34 <rtems_blkdev_generic_read+0x60>                 <== NOT EXECUTED
40001ba0:   90 10 00 10     mov  %l0, %o0                                                 <== NOT EXECUTED
        blkofs = 0;                                                                       
        block++;                                                                          
    }                                                                                     
                                                                                          
    return rc;                                                                            
}                                                                                         
40001ba4:   81 c7 e0 08     ret                                                           <== NOT EXECUTED
40001ba8:   81 e8 00 00     restore                                                       <== NOT EXECUTED
        if (rc != RTEMS_SUCCESSFUL)                                                       
40001bac:   81 c7 e0 08     ret                                                           <== NOT EXECUTED
40001bb0:   91 e8 20 00     restore  %g0, 0, %o0                                          <== NOT EXECUTED
40001bb4:   b0 10 00 1c     mov  %i4, %i0                                                 <== NOT EXECUTED
}                                                                                         
40001bb8:   81 c7 e0 08     ret                                                           <== NOT EXECUTED
40001bbc:   81 e8 00 00     restore                                                       <== NOT EXECUTED
                                                                                          
===============================================================================
40001bc0 <rtems_blkdev_generic_write>:                                                    
rtems_device_driver                                                                       
rtems_blkdev_generic_write(                                                               
    rtems_device_major_number major RTEMS_UNUSED,                                         
    rtems_device_minor_number minor RTEMS_UNUSED,                                         
    void                    * arg)                                                        
{                                                                                         
40001bc0:   9d e3 bf 98     save  %sp, -104, %sp                                          <== NOT EXECUTED
    rtems_status_code rc = RTEMS_SUCCESSFUL;                                              
    rtems_libio_rw_args_t *args = arg;                                                    
    rtems_libio_t *iop = args->iop;                                                       
    rtems_disk_device *dd = iop->data1;                                                   
40001bc4:   c2 06 80 00     ld  [ %i2 ], %g1                                              <== NOT EXECUTED
40001bc8:   e0 00 60 2c     ld  [ %g1 + 0x2c ], %l0                                       <== NOT EXECUTED
    uint32_t block_size = dd->block_size;                                                 
    char *buf = args->buffer;                                                             
    uint32_t count = args->count;                                                         
    rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);            
40001bcc:   f8 1e a0 08     ldd  [ %i2 + 8 ], %i4                                         <== NOT EXECUTED
    uint32_t block_size = dd->block_size;                                                 
40001bd0:   f0 04 20 24     ld  [ %l0 + 0x24 ], %i0                                       <== NOT EXECUTED
    rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);            
40001bd4:   94 10 20 00     clr  %o2                                                      <== NOT EXECUTED
40001bd8:   96 10 00 18     mov  %i0, %o3                                                 <== NOT EXECUTED
40001bdc:   90 10 00 1c     mov  %i4, %o0                                                 <== NOT EXECUTED
40001be0:   40 00 3e f2     call  400117a8 <__divdi3>                                     <== NOT EXECUTED
40001be4:   92 10 00 1d     mov  %i5, %o1                                                 <== NOT EXECUTED
    uint32_t blkofs = (uint32_t) (args->offset % block_size);                             
40001be8:   90 10 00 1c     mov  %i4, %o0                                                 <== NOT EXECUTED
40001bec:   94 10 20 00     clr  %o2                                                      <== NOT EXECUTED
    rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);            
40001bf0:   b2 10 00 09     mov  %o1, %i1                                                 <== NOT EXECUTED
    uint32_t blkofs = (uint32_t) (args->offset % block_size);                             
40001bf4:   96 10 00 18     mov  %i0, %o3                                                 <== NOT EXECUTED
40001bf8:   40 00 3f 77     call  400119d4 <__moddi3>                                     <== NOT EXECUTED
40001bfc:   92 10 00 1d     mov  %i5, %o1                                                 <== NOT EXECUTED
                                                                                          
    args->bytes_moved = 0;                                                                
40001c00:   c0 26 a0 1c     clr  [ %i2 + 0x1c ]                                           <== NOT EXECUTED
    uint32_t blkofs = (uint32_t) (args->offset % block_size);                             
40001c04:   b8 10 00 09     mov  %o1, %i4                                                 <== NOT EXECUTED
    uint32_t count = args->count;                                                         
40001c08:   f6 06 a0 14     ld  [ %i2 + 0x14 ], %i3                                       <== NOT EXECUTED
                                                                                          
    while (count > 0)                                                                     
40001c0c:   80 a6 e0 00     cmp  %i3, 0                                                   <== NOT EXECUTED
40001c10:   12 80 00 1e     bne  40001c88 <rtems_blkdev_generic_write+0xc8>               <== NOT EXECUTED
40001c14:   e2 06 a0 10     ld  [ %i2 + 0x10 ], %l1                                       <== NOT EXECUTED
            copy = count;                                                                 
        memcpy((char *)diskbuf->buffer + blkofs, buf, copy);                              
        args->bytes_moved += copy;                                                        
                                                                                          
        rc = rtems_bdbuf_release_modified(diskbuf);                                       
        if (rc != RTEMS_SUCCESSFUL)                                                       
40001c18:   10 80 00 2b     b  40001cc4 <rtems_blkdev_generic_write+0x104>                <== NOT EXECUTED
40001c1c:   90 10 20 00     clr  %o0                                                      <== NOT EXECUTED
            rc = rtems_bdbuf_get(dd, block, &diskbuf);                                    
40001c20:   94 07 bf fc     add  %fp, -4, %o2                                             <== NOT EXECUTED
40001c24:   40 00 29 dc     call  4000c394 <rtems_bdbuf_get>                              <== NOT EXECUTED
40001c28:   90 10 00 10     mov  %l0, %o0                                                 <== NOT EXECUTED
        if (rc != RTEMS_SUCCESSFUL)                                                       
40001c2c:   80 a2 20 00     cmp  %o0, 0                                                   <== NOT EXECUTED
40001c30:   12 80 00 22     bne  40001cb8 <rtems_blkdev_generic_write+0xf8>               <== NOT EXECUTED
40001c34:   92 10 00 11     mov  %l1, %o1                                                 <== NOT EXECUTED
        copy = block_size - blkofs;                                                       
40001c38:   ba 26 00 1c     sub  %i0, %i4, %i5                                            <== NOT EXECUTED
        if (copy > count)                                                                 
40001c3c:   80 a7 40 1b     cmp  %i5, %i3                                                 <== NOT EXECUTED
40001c40:   38 80 00 02     bgu,a   40001c48 <rtems_blkdev_generic_write+0x88>            <== NOT EXECUTED
40001c44:   ba 10 00 1b     mov  %i3, %i5                                                 <== NOT EXECUTED
        memcpy((char *)diskbuf->buffer + blkofs, buf, copy);                              
40001c48:   c2 07 bf fc     ld  [ %fp + -4 ], %g1                                         <== NOT EXECUTED
40001c4c:   d0 00 60 1c     ld  [ %g1 + 0x1c ], %o0                                       <== NOT EXECUTED
40001c50:   94 10 00 1d     mov  %i5, %o2                                                 <== NOT EXECUTED
40001c54:   40 00 44 46     call  40012d6c <memcpy>                                       <== NOT EXECUTED
40001c58:   90 02 00 1c     add  %o0, %i4, %o0                                            <== NOT EXECUTED
        args->bytes_moved += copy;                                                        
40001c5c:   c2 06 a0 1c     ld  [ %i2 + 0x1c ], %g1                                       <== NOT EXECUTED
40001c60:   82 00 40 1d     add  %g1, %i5, %g1                                            <== NOT EXECUTED
40001c64:   c2 26 a0 1c     st  %g1, [ %i2 + 0x1c ]                                       <== NOT EXECUTED
            break;                                                                        
                                                                                          
        count -= copy;                                                                    
        buf += copy;                                                                      
40001c68:   a2 04 40 1d     add  %l1, %i5, %l1                                            <== NOT EXECUTED
        rc = rtems_bdbuf_release_modified(diskbuf);                                       
40001c6c:   40 00 2a d9     call  4000c7d0 <rtems_bdbuf_release_modified>                 <== NOT EXECUTED
40001c70:   d0 07 bf fc     ld  [ %fp + -4 ], %o0                                         <== NOT EXECUTED
        if (rc != RTEMS_SUCCESSFUL)                                                       
40001c74:   b8 92 20 00     orcc  %o0, 0, %i4                                             <== NOT EXECUTED
40001c78:   12 80 00 15     bne  40001ccc <rtems_blkdev_generic_write+0x10c>              <== NOT EXECUTED
40001c7c:   b6 a6 c0 1d     subcc  %i3, %i5, %i3                                          <== NOT EXECUTED
    while (count > 0)                                                                     
40001c80:   02 80 00 10     be  40001cc0 <rtems_blkdev_generic_write+0x100>               <== NOT EXECUTED
40001c84:   b2 06 60 01     inc  %i1                                                      <== NOT EXECUTED
        if ((blkofs == 0) && (count >= block_size))                                       
40001c88:   80 a7 20 00     cmp  %i4, 0                                                   <== NOT EXECUTED
40001c8c:   12 80 00 04     bne  40001c9c <rtems_blkdev_generic_write+0xdc>               <== NOT EXECUTED
40001c90:   80 a6 c0 18     cmp  %i3, %i0                                                 <== NOT EXECUTED
40001c94:   3a bf ff e3     bcc,a   40001c20 <rtems_blkdev_generic_write+0x60>            <== NOT EXECUTED
40001c98:   92 10 00 19     mov  %i1, %o1                                                 <== NOT EXECUTED
            rc = rtems_bdbuf_read(dd, block, &diskbuf);                                   
40001c9c:   92 10 00 19     mov  %i1, %o1                                                 <== NOT EXECUTED
40001ca0:   94 07 bf fc     add  %fp, -4, %o2                                             <== NOT EXECUTED
40001ca4:   40 00 29 fc     call  4000c494 <rtems_bdbuf_read>                             <== NOT EXECUTED
40001ca8:   90 10 00 10     mov  %l0, %o0                                                 <== NOT EXECUTED
        if (rc != RTEMS_SUCCESSFUL)                                                       
40001cac:   80 a2 20 00     cmp  %o0, 0                                                   <== NOT EXECUTED
40001cb0:   02 bf ff e2     be  40001c38 <rtems_blkdev_generic_write+0x78>                <== NOT EXECUTED
40001cb4:   92 10 00 11     mov  %l1, %o1                                                 <== NOT EXECUTED
        blkofs = 0;                                                                       
        block++;                                                                          
    }                                                                                     
                                                                                          
    return rc;                                                                            
}                                                                                         
40001cb8:   81 c7 e0 08     ret                                                           <== NOT EXECUTED
40001cbc:   91 e8 00 08     restore  %g0, %o0, %o0                                        <== NOT EXECUTED
        if (rc != RTEMS_SUCCESSFUL)                                                       
40001cc0:   90 10 20 00     clr  %o0                                                      <== NOT EXECUTED
}                                                                                         
40001cc4:   81 c7 e0 08     ret                                                           <== NOT EXECUTED
40001cc8:   91 e8 00 08     restore  %g0, %o0, %o0                                        <== NOT EXECUTED
        if (rc != RTEMS_SUCCESSFUL)                                                       
40001ccc:   90 10 00 1c     mov  %i4, %o0                                                 <== NOT EXECUTED
}                                                                                         
40001cd0:   81 c7 e0 08     ret                                                           <== NOT EXECUTED
40001cd4:   91 e8 00 08     restore  %g0, %o0, %o0                                        <== NOT EXECUTED
                                                                                          
===============================================================================
4000f694 <rtems_blkdev_ioctl>:                                                            
#include <rtems/blkdev.h>                                                                 
#include <rtems/bdbuf.h>                                                                  
                                                                                          
int                                                                                       
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)                       
{                                                                                         
4000f694:   9d e3 bf a0     save  %sp, -96, %sp                                           
    rtems_status_code  sc;                                                                
    int                rc = 0;                                                            
                                                                                          
    switch (req)                                                                          
4000f698:   03 10 01 10     sethi  %hi(0x40044000), %g1                                   
4000f69c:   84 10 62 0b     or  %g1, 0x20b, %g2 ! 4004420b <__end+0x1e7db>                
4000f6a0:   80 a6 40 02     cmp  %i1, %g2                                                 
4000f6a4:   18 80 00 0f     bgu  4000f6e0 <rtems_blkdev_ioctl+0x4c>                       
4000f6a8:   82 10 62 01     or  %g1, 0x201, %g1                                           
4000f6ac:   80 a6 40 01     cmp  %i1, %g1                                                 
4000f6b0:   08 80 00 19     bleu  4000f714 <rtems_blkdev_ioctl+0x80>                      
4000f6b4:   03 2f fe ef     sethi  %hi(0xbffbbc00), %g1                                   
4000f6b8:   82 10 61 fe     or  %g1, 0x1fe, %g1 ! bffbbdfe <RAM_END+0x7fbbbdfe>           
4000f6bc:   b2 06 40 01     add  %i1, %g1, %i1                                            
4000f6c0:   80 a6 60 09     cmp  %i1, 9                                                   
4000f6c4:   18 80 00 2f     bgu  4000f780 <rtems_blkdev_ioctl+0xec>                       <== NEVER TAKEN
4000f6c8:   b3 2e 60 02     sll  %i1, 2, %i1                                              
4000f6cc:   03 10 00 3d     sethi  %hi(0x4000f400), %g1                                   
4000f6d0:   82 10 62 6c     or  %g1, 0x26c, %g1 ! 4000f66c <rtems_bdbuf_reset_device_stats+0x2c>
4000f6d4:   c2 00 40 19     ld  [ %g1 + %i1 ], %g1                                        
4000f6d8:   81 c0 40 00     jmp  %g1                                                      
4000f6dc:   01 00 00 00     nop                                                           
4000f6e0:   03 20 01 10     sethi  %hi(0x80044000), %g1                                   
4000f6e4:   82 10 62 04     or  %g1, 0x204, %g1 ! 80044204 <RAM_END+0x3fc44204>           
4000f6e8:   80 a6 40 01     cmp  %i1, %g1                                                 
4000f6ec:   12 80 00 25     bne  4000f780 <rtems_blkdev_ioctl+0xec>                       <== NEVER TAKEN
4000f6f0:   94 10 20 01     mov  1, %o2                                                   
        case RTEMS_BLKIO_GETBLKSIZE:                                                      
            *(uint32_t *) argp = dd->block_size;                                          
            break;                                                                        
                                                                                          
        case RTEMS_BLKIO_SETBLKSIZE:                                                      
            sc = rtems_bdbuf_set_block_size(dd, *(uint32_t *) argp, true);                
4000f6f4:   d2 06 80 00     ld  [ %i2 ], %o1                                              
4000f6f8:   7f ff ff 74     call  4000f4c8 <rtems_bdbuf_set_block_size>                   
4000f6fc:   90 10 00 18     mov  %i0, %o0                                                 
            if (sc != RTEMS_SUCCESSFUL) {                                                 
4000f700:   80 a2 20 00     cmp  %o0, 0                                                   
4000f704:   12 80 00 19     bne  4000f768 <rtems_blkdev_ioctl+0xd4>                       <== NEVER TAKEN
4000f708:   01 00 00 00     nop                                                           
            }                                                                             
            break;                                                                        
                                                                                          
        case RTEMS_BLKIO_GETSIZE:                                                         
            *(rtems_blkdev_bnum *) argp = dd->size;                                       
            break;                                                                        
4000f70c:   81 c7 e0 08     ret                                                           
4000f710:   91 e8 20 00     restore  %g0, 0, %o0                                          
    switch (req)                                                                          
4000f714:   03 08 00 10     sethi  %hi(0x20004000), %g1                                   
4000f718:   84 10 62 0a     or  %g1, 0x20a, %g2 ! 2000420a <RAM_SIZE+0x1fc0420a>          
4000f71c:   80 a6 40 02     cmp  %i1, %g2                                                 
4000f720:   02 80 00 33     be  4000f7ec <rtems_blkdev_ioctl+0x158>                       
4000f724:   84 10 62 0c     or  %g1, 0x20c, %g2                                           
4000f728:   80 a6 40 02     cmp  %i1, %g2                                                 
4000f72c:   12 80 00 06     bne  4000f744 <rtems_blkdev_ioctl+0xb0>                       
4000f730:   90 10 00 18     mov  %i0, %o0                                                 
        case RTEMS_BLKIO_GETDEVSTATS:                                                     
            rtems_bdbuf_get_device_stats(dd, (rtems_blkdev_stats *) argp);                
            break;                                                                        
                                                                                          
        case RTEMS_BLKIO_RESETDEVSTATS:                                                   
            rtems_bdbuf_reset_device_stats(dd);                                           
4000f734:   7f ff ff c3     call  4000f640 <rtems_bdbuf_reset_device_stats>               
4000f738:   b0 10 20 00     clr  %i0                                                      
            break;                                                                        
4000f73c:   81 c7 e0 08     ret                                                           
4000f740:   81 e8 00 00     restore                                                       
    switch (req)                                                                          
4000f744:   82 10 62 06     or  %g1, 0x206, %g1                                           
4000f748:   80 a6 40 01     cmp  %i1, %g1                                                 
4000f74c:   12 80 00 0d     bne  4000f780 <rtems_blkdev_ioctl+0xec>                       
4000f750:   01 00 00 00     nop                                                           
            sc = rtems_bdbuf_syncdev(dd);                                                 
4000f754:   7f ff ff 2b     call  4000f400 <rtems_bdbuf_syncdev>                          
4000f758:   90 10 00 18     mov  %i0, %o0                                                 
            if (sc != RTEMS_SUCCESSFUL) {                                                 
4000f75c:   80 a2 20 00     cmp  %o0, 0                                                   
4000f760:   02 bf ff eb     be  4000f70c <rtems_blkdev_ioctl+0x78>                        <== ALWAYS TAKEN
4000f764:   01 00 00 00     nop                                                           
                errno = EIO;                                                              
4000f768:   40 00 16 6a     call  40015110 <__errno>                                      <== NOT EXECUTED
4000f76c:   b0 10 3f ff     mov  -1, %i0    ! ffffffff <RAM_END+0xbfbfffff>               <== NOT EXECUTED
4000f770:   82 10 20 05     mov  5, %g1                                                   <== NOT EXECUTED
4000f774:   c2 22 00 00     st  %g1, [ %o0 ]                                              <== NOT EXECUTED
                rc = -1;                                                                  
4000f778:   81 c7 e0 08     ret                                                           <== NOT EXECUTED
4000f77c:   81 e8 00 00     restore                                                       <== NOT EXECUTED
                                                                                          
        default:                                                                          
            errno = EINVAL;                                                               
4000f780:   40 00 16 64     call  40015110 <__errno>                                      
4000f784:   b0 10 3f ff     mov  -1, %i0                                                  
4000f788:   82 10 20 16     mov  0x16, %g1                                                
4000f78c:   c2 22 00 00     st  %g1, [ %o0 ]                                              
            rc = -1;                                                                      
            break;                                                                        
    }                                                                                     
                                                                                          
    return rc;                                                                            
}                                                                                         
4000f790:   81 c7 e0 08     ret                                                           
4000f794:   81 e8 00 00     restore                                                       
            *(uint32_t *) argp = dd->media_block_size;                                    
4000f798:   c2 06 20 20     ld  [ %i0 + 0x20 ], %g1                                       
4000f79c:   c2 26 80 00     st  %g1, [ %i2 ]                                              
            break;                                                                        
4000f7a0:   81 c7 e0 08     ret                                                           
4000f7a4:   91 e8 20 00     restore  %g0, 0, %o0                                          
            *(uint32_t *) argp = dd->block_size;                                          
4000f7a8:   c2 06 20 24     ld  [ %i0 + 0x24 ], %g1                                       
4000f7ac:   c2 26 80 00     st  %g1, [ %i2 ]                                              
            break;                                                                        
4000f7b0:   81 c7 e0 08     ret                                                           
4000f7b4:   91 e8 20 00     restore  %g0, 0, %o0                                          
            *(rtems_blkdev_bnum *) argp = dd->size;                                       
4000f7b8:   c2 06 20 1c     ld  [ %i0 + 0x1c ], %g1                                       
4000f7bc:   c2 26 80 00     st  %g1, [ %i2 ]                                              
            break;                                                                        
4000f7c0:   81 c7 e0 08     ret                                                           
4000f7c4:   91 e8 20 00     restore  %g0, 0, %o0                                          
            *(rtems_disk_device **) argp = dd;                                            
4000f7c8:   f0 26 80 00     st  %i0, [ %i2 ]                                              
            break;                                                                        
4000f7cc:   81 c7 e0 08     ret                                                           
4000f7d0:   91 e8 20 00     restore  %g0, 0, %o0                                          
            rtems_bdbuf_get_device_stats(dd, (rtems_blkdev_stats *) argp);                
4000f7d4:   90 10 00 18     mov  %i0, %o0                                                 
4000f7d8:   92 10 00 1a     mov  %i2, %o1                                                 
4000f7dc:   7f ff ff 8e     call  4000f614 <rtems_bdbuf_get_device_stats>                 
4000f7e0:   b0 10 20 00     clr  %i0                                                      
            break;                                                                        
4000f7e4:   81 c7 e0 08     ret                                                           
4000f7e8:   81 e8 00 00     restore                                                       
            rtems_bdbuf_purge_dev(dd);                                                    
4000f7ec:   90 10 00 18     mov  %i0, %o0                                                 
4000f7f0:   7f ff ff 2c     call  4000f4a0 <rtems_bdbuf_purge_dev>                        
4000f7f4:   b0 10 20 00     clr  %i0                                                      
            break;                                                                        
4000f7f8:   81 c7 e0 08     ret                                                           
4000f7fc:   81 e8 00 00     restore                                                       
                                                                                          
===============================================================================
40002278 <rtems_disk_create_log>:                                                         
{                                                                                         
40002278:   9d e3 bf 98     save  %sp, -104, %sp                                          
  _Mutex_Acquire( mutex );                                                                
4000227c:   21 10 00 59     sethi  %hi(0x40016400), %l0                                   
  rtems_disk_device *dd = NULL;                                                           
40002280:   c0 27 bf f8     clr  [ %fp + -8 ]                                             
40002284:   90 14 23 fc     or  %l0, 0x3fc, %o0                                           
40002288:   40 00 13 f2     call  40007250 <_Mutex_Acquire>                               
4000228c:   c0 27 bf fc     clr  [ %fp + -4 ]                                             
  phys_dd = get_disk_entry(phys, true);                                                   
40002290:   90 10 00 1a     mov  %i2, %o0                                                 
  diskdevs_protected = true;                                                              
40002294:   23 10 00 61     sethi  %hi(0x40018400), %l1                                   
40002298:   a4 10 20 01     mov  1, %l2                                                   
  phys_dd = get_disk_entry(phys, true);                                                   
4000229c:   94 10 20 01     mov  1, %o2                                                   
  diskdevs_protected = true;                                                              
400022a0:   e4 2c 62 7c     stb  %l2, [ %l1 + 0x27c ]                                     
  phys_dd = get_disk_entry(phys, true);                                                   
400022a4:   7f ff fe b0     call  40001d64 <get_disk_entry>                               
400022a8:   92 10 00 1b     mov  %i3, %o1                                                 
  if (phys_dd == NULL) {                                                                  
400022ac:   b4 92 20 00     orcc  %o0, 0, %i2                                             
400022b0:   02 80 00 2a     be  40002358 <rtems_disk_create_log+0xe0>                     
400022b4:   d4 07 a0 5c     ld  [ %fp + 0x5c ], %o2                                       
  sc = create_disk(dev, name, &dd, &alloc_name);                                          
400022b8:   98 07 bf fc     add  %fp, -4, %o4                                             
400022bc:   96 07 bf f8     add  %fp, -8, %o3                                             
400022c0:   90 10 00 18     mov  %i0, %o0                                                 
400022c4:   7f ff fe cf     call  40001e00 <create_disk>                                  
400022c8:   92 10 00 19     mov  %i1, %o1                                                 
  if (sc != RTEMS_SUCCESSFUL) {                                                           
400022cc:   b6 92 20 00     orcc  %o0, 0, %i3                                             
400022d0:   12 80 00 0f     bne  4000230c <rtems_disk_create_log+0x94>                    
400022d4:   d0 07 bf f8     ld  [ %fp + -8 ], %o0                                         
  sc = rtems_disk_init_log(                                                               
400022d8:   96 10 00 1d     mov  %i5, %o3                                                 
400022dc:   94 10 00 1c     mov  %i4, %o2                                                 
400022e0:   40 00 00 e6     call  40002678 <rtems_disk_init_log>                          
400022e4:   92 10 00 1a     mov  %i2, %o1                                                 
  dd->name = alloc_name;                                                                  
400022e8:   c4 1f bf f8     ldd  [ %fp + -8 ], %g2                                        
  ++phys_dd->uses;                                                                        
400022ec:   c2 06 a0 14     ld  [ %i2 + 0x14 ], %g1                                       
  dd->dev = dev;                                                                          
400022f0:   f0 38 80 00     std  %i0, [ %g2 ]                                             
  ++phys_dd->uses;                                                                        
400022f4:   82 00 60 01     inc  %g1                                                      
  dd->name = alloc_name;                                                                  
400022f8:   c6 20 a0 10     st  %g3, [ %g2 + 0x10 ]                                       
  sc = rtems_disk_init_log(                                                               
400022fc:   b6 10 00 08     mov  %o0, %i3                                                 
  if (sc != RTEMS_SUCCESSFUL) {                                                           
40002300:   80 a2 20 00     cmp  %o0, 0                                                   
40002304:   12 80 00 08     bne  40002324 <rtems_disk_create_log+0xac>                    
40002308:   c2 26 a0 14     st  %g1, [ %i2 + 0x14 ]                                       
  diskdevs_protected = false;                                                             
4000230c:   c0 2c 62 7c     clrb  [ %l1 + 0x27c ]                                         
  _Mutex_Release( mutex );                                                                
40002310:   90 14 23 fc     or  %l0, 0x3fc, %o0                                           
40002314:   40 00 13 ea     call  400072bc <_Mutex_Release>                               
40002318:   b0 10 00 1b     mov  %i3, %i0                                                 
}                                                                                         
4000231c:   81 c7 e0 08     ret                                                           
40002320:   81 e8 00 00     restore                                                       
    dd->ioctl = null_handler;                                                             
40002324:   03 10 00 07     sethi  %hi(0x40001c00), %g1                                   
40002328:   82 10 61 f8     or  %g1, 0x1f8, %g1 ! 40001df8 <null_handler>                 
4000232c:   c2 20 a0 38     st  %g1, [ %g2 + 0x38 ]                                       
  dd = get_disk_entry(dev, true);                                                         
40002330:   94 10 20 01     mov  1, %o2                                                   
40002334:   90 10 00 18     mov  %i0, %o0                                                 
40002338:   7f ff fe 8b     call  40001d64 <get_disk_entry>                               
4000233c:   92 10 00 19     mov  %i1, %o1                                                 
  if (dd == NULL) {                                                                       
40002340:   82 92 20 00     orcc  %o0, 0, %g1                                             
40002344:   02 bf ff f2     be  4000230c <rtems_disk_create_log+0x94>                     <== NEVER TAKEN
40002348:   01 00 00 00     nop                                                           
  rtems_disk_cleanup(dd);                                                                 
4000234c:   7f ff ff 32     call  40002014 <rtems_disk_cleanup.constprop.0>               
40002350:   e4 28 60 40     stb  %l2, [ %g1 + 0x40 ]                                      
  return RTEMS_SUCCESSFUL;                                                                
40002354:   30 bf ff ee     b,a   4000230c <rtems_disk_create_log+0x94>                   
  diskdevs_protected = false;                                                             
40002358:   c0 2c 62 7c     clrb  [ %l1 + 0x27c ]                                         
4000235c:   90 14 23 fc     or  %l0, 0x3fc, %o0                                           
40002360:   40 00 13 d7     call  400072bc <_Mutex_Release>                               
40002364:   b6 10 20 04     mov  4, %i3                                                   
}                                                                                         
40002368:   81 c7 e0 08     ret                                                           
4000236c:   91 e8 00 1b     restore  %g0, %i3, %o0                                        
                                                                                          
===============================================================================
40002194 <rtems_disk_create_phys>:                                                        
{                                                                                         
40002194:   9d e3 bf 98     save  %sp, -104, %sp                                          
  rtems_disk_device *dd = NULL;                                                           
40002198:   c0 27 bf f8     clr  [ %fp + -8 ]                                             
{                                                                                         
4000219c:   a0 10 00 18     mov  %i0, %l0                                                 
  char *alloc_name = NULL;                                                                
400021a0:   c0 27 bf fc     clr  [ %fp + -4 ]                                             
  if (handler == NULL) {                                                                  
400021a4:   80 a7 20 00     cmp  %i4, 0                                                   
400021a8:   02 80 00 31     be  4000226c <rtems_disk_create_phys+0xd8>                    
400021ac:   a2 10 00 19     mov  %i1, %l1                                                 
  mutex->_Queue._name = name;                                                             
}                                                                                         
                                                                                          
static __inline void rtems_mutex_lock( rtems_mutex *mutex )                               
{                                                                                         
  _Mutex_Acquire( mutex );                                                                
400021b0:   31 10 00 59     sethi  %hi(0x40016400), %i0                                   
400021b4:   40 00 14 27     call  40007250 <_Mutex_Acquire>                               
400021b8:   90 16 23 fc     or  %i0, 0x3fc, %o0 ! 400167fc <diskdevs_mutex>               
  sc = create_disk(dev, name, &dd, &alloc_name);                                          
400021bc:   d4 07 a0 5c     ld  [ %fp + 0x5c ], %o2                                       
400021c0:   92 10 00 19     mov  %i1, %o1                                                 
  diskdevs_protected = true;                                                              
400021c4:   25 10 00 61     sethi  %hi(0x40018400), %l2                                   
400021c8:   a6 10 20 01     mov  1, %l3                                                   
  sc = create_disk(dev, name, &dd, &alloc_name);                                          
400021cc:   98 07 bf fc     add  %fp, -4, %o4                                             
  diskdevs_protected = true;                                                              
400021d0:   e6 2c a2 7c     stb  %l3, [ %l2 + 0x27c ]                                     
  sc = create_disk(dev, name, &dd, &alloc_name);                                          
400021d4:   96 07 bf f8     add  %fp, -8, %o3                                             
400021d8:   7f ff ff 0a     call  40001e00 <create_disk>                                  
400021dc:   90 10 00 10     mov  %l0, %o0                                                 
  if (sc != RTEMS_SUCCESSFUL) {                                                           
400021e0:   b2 92 20 00     orcc  %o0, 0, %i1                                             
400021e4:   12 80 00 0e     bne  4000221c <rtems_disk_create_phys+0x88>                   
400021e8:   d0 07 bf f8     ld  [ %fp + -8 ], %o0                                         
  sc = rtems_disk_init_phys(                                                              
400021ec:   98 10 00 1d     mov  %i5, %o4                                                 
400021f0:   96 10 00 1c     mov  %i4, %o3                                                 
400021f4:   94 10 00 1b     mov  %i3, %o2                                                 
400021f8:   40 00 01 06     call  40002610 <rtems_disk_init_phys>                         
400021fc:   92 10 00 1a     mov  %i2, %o1                                                 
  dd->dev = dev;                                                                          
40002200:   c2 07 bf f8     ld  [ %fp + -8 ], %g1                                         
  dd->name = alloc_name;                                                                  
40002204:   c4 07 bf fc     ld  [ %fp + -4 ], %g2                                         
40002208:   c4 20 60 10     st  %g2, [ %g1 + 0x10 ]                                       
  sc = rtems_disk_init_phys(                                                              
4000220c:   b2 10 00 08     mov  %o0, %i1                                                 
  if (sc != RTEMS_SUCCESSFUL) {                                                           
40002210:   80 a2 20 00     cmp  %o0, 0                                                   
40002214:   12 80 00 08     bne  40002234 <rtems_disk_create_phys+0xa0>                   
40002218:   e0 38 40 00     std  %l0, [ %g1 ]                                             
}                                                                                         
                                                                                          
static __inline void rtems_mutex_unlock( rtems_mutex *mutex )                             
{                                                                                         
  _Mutex_Release( mutex );                                                                
4000221c:   90 16 23 fc     or  %i0, 0x3fc, %o0                                           
  diskdevs_protected = false;                                                             
40002220:   c0 2c a2 7c     clrb  [ %l2 + 0x27c ]                                         
40002224:   40 00 14 26     call  400072bc <_Mutex_Release>                               
40002228:   b0 10 00 19     mov  %i1, %i0                                                 
}                                                                                         
4000222c:   81 c7 e0 08     ret                                                           
40002230:   81 e8 00 00     restore                                                       
    dd->ioctl = null_handler;                                                             
40002234:   05 10 00 07     sethi  %hi(0x40001c00), %g2                                   
40002238:   84 10 a1 f8     or  %g2, 0x1f8, %g2 ! 40001df8 <null_handler>                 
4000223c:   c4 20 60 38     st  %g2, [ %g1 + 0x38 ]                                       
static rtems_status_code                                                                  
disk_delete_locked(dev_t dev)                                                             
{                                                                                         
  rtems_disk_device *dd = NULL;                                                           
                                                                                          
  dd = get_disk_entry(dev, true);                                                         
40002240:   94 10 20 01     mov  1, %o2                                                   
40002244:   90 10 00 10     mov  %l0, %o0                                                 
40002248:   7f ff fe c7     call  40001d64 <get_disk_entry>                               
4000224c:   92 10 00 11     mov  %l1, %o1                                                 
  if (dd == NULL) {                                                                       
40002250:   82 92 20 00     orcc  %o0, 0, %g1                                             
40002254:   22 bf ff f3     be,a   40002220 <rtems_disk_create_phys+0x8c>                 <== NEVER TAKEN
40002258:   90 16 23 fc     or  %i0, 0x3fc, %o0                                           <== NOT EXECUTED
    return RTEMS_INVALID_ID;                                                              
  }                                                                                       
                                                                                          
  dd->deleted = true;                                                                     
  rtems_disk_cleanup(dd);                                                                 
4000225c:   7f ff ff 6e     call  40002014 <rtems_disk_cleanup.constprop.0>               
40002260:   e6 28 60 40     stb  %l3, [ %g1 + 0x40 ]                                      
                                                                                          
  return RTEMS_SUCCESSFUL;                                                                
40002264:   10 bf ff ef     b  40002220 <rtems_disk_create_phys+0x8c>                     
40002268:   90 16 23 fc     or  %i0, 0x3fc, %o0                                           
    return RTEMS_INVALID_ADDRESS;                                                         
4000226c:   b2 10 20 09     mov  9, %i1                                                   
}                                                                                         
40002270:   81 c7 e0 08     ret                                                           
40002274:   91 e8 00 19     restore  %g0, %i1, %o0                                        
                                                                                          
===============================================================================
40002370 <rtems_disk_delete>:                                                             
}                                                                                         
                                                                                          
rtems_status_code                                                                         
rtems_disk_delete(dev_t dev)                                                              
{                                                                                         
40002370:   9d e3 bf a0     save  %sp, -96, %sp                                           
  _Mutex_Acquire( mutex );                                                                
40002374:   3b 10 00 59     sethi  %hi(0x40016400), %i5                                   
40002378:   40 00 13 b6     call  40007250 <_Mutex_Acquire>                               
4000237c:   90 17 63 fc     or  %i5, 0x3fc, %o0 ! 400167fc <diskdevs_mutex>               
  diskdevs_protected = true;                                                              
40002380:   39 10 00 61     sethi  %hi(0x40018400), %i4                                   
40002384:   b6 10 20 01     mov  1, %i3                                                   
  dd = get_disk_entry(dev, true);                                                         
40002388:   94 10 20 01     mov  1, %o2                                                   
  diskdevs_protected = true;                                                              
4000238c:   f6 2f 22 7c     stb  %i3, [ %i4 + 0x27c ]                                     
  dd = get_disk_entry(dev, true);                                                         
40002390:   90 10 00 18     mov  %i0, %o0                                                 
40002394:   7f ff fe 74     call  40001d64 <get_disk_entry>                               
40002398:   92 10 00 19     mov  %i1, %o1                                                 
  if (dd == NULL) {                                                                       
4000239c:   82 92 20 00     orcc  %o0, 0, %g1                                             
400023a0:   22 80 00 0b     be,a   400023cc <rtems_disk_delete+0x5c>                      <== NEVER TAKEN
400023a4:   b0 10 20 04     mov  4, %i0                                                   <== NOT EXECUTED
  dd->deleted = true;                                                                     
400023a8:   f6 28 60 40     stb  %i3, [ %g1 + 0x40 ]                                      
  rtems_disk_cleanup(dd);                                                                 
400023ac:   7f ff ff 1a     call  40002014 <rtems_disk_cleanup.constprop.0>               
400023b0:   b0 10 20 00     clr  %i0                                                      
  _Mutex_Release( mutex );                                                                
400023b4:   90 17 63 fc     or  %i5, 0x3fc, %o0                                           
  diskdevs_protected = false;                                                             
400023b8:   c0 2f 22 7c     clrb  [ %i4 + 0x27c ]                                         
400023bc:   40 00 13 c0     call  400072bc <_Mutex_Release>                               
400023c0:   01 00 00 00     nop                                                           
  disk_lock();                                                                            
  sc = disk_delete_locked(dev);                                                           
  disk_unlock();                                                                          
                                                                                          
  return sc;                                                                              
}                                                                                         
400023c4:   81 c7 e0 08     ret                                                           
400023c8:   81 e8 00 00     restore                                                       
  diskdevs_protected = false;                                                             
400023cc:   c0 2f 22 7c     clrb  [ %i4 + 0x27c ]                                         <== NOT EXECUTED
400023d0:   40 00 13 bb     call  400072bc <_Mutex_Release>                               <== NOT EXECUTED
400023d4:   90 17 63 fc     or  %i5, 0x3fc, %o0                                           <== NOT EXECUTED
}                                                                                         
400023d8:   81 c7 e0 08     ret                                                           <== NOT EXECUTED
400023dc:   81 e8 00 00     restore                                                       <== NOT EXECUTED
                                                                                          
===============================================================================
40002564 <rtems_disk_io_done>:                                                            
                                                                                          
rtems_status_code                                                                         
rtems_disk_io_done(void)                                                                  
{                                                                                         
40002564:   9d e3 bf a0     save  %sp, -96, %sp                                           
  rtems_device_major_number major = 0;                                                    
  rtems_device_minor_number minor = 0;                                                    
                                                                                          
  for (major = 0; major < disktab_size; ++major) {                                        
40002568:   21 10 00 61     sethi  %hi(0x40018400), %l0                                   
4000256c:   c2 04 22 80     ld  [ %l0 + 0x280 ], %g1    ! 40018680 <disktab_size>         
    rtems_disk_device_table *dtab = disktab + major;                                      
40002570:   35 10 00 61     sethi  %hi(0x40018400), %i2                                   
  for (major = 0; major < disktab_size; ++major) {                                        
40002574:   80 a0 60 00     cmp  %g1, 0                                                   
40002578:   02 80 00 1f     be  400025f4 <rtems_disk_io_done+0x90>                        <== NEVER TAKEN
4000257c:   fa 06 a2 84     ld  [ %i2 + 0x284 ], %i5                                      
40002580:   b6 10 20 00     clr  %i3                                                      
40002584:   b2 14 22 80     or  %l0, 0x280, %i1                                           
    rtems_disk_device_table *dtab = disktab + major;                                      
40002588:   83 2e e0 03     sll  %i3, 3, %g1                                              
4000258c:   b8 07 40 01     add  %i5, %g1, %i4                                            
                                                                                          
    for (minor = 0; minor < dtab->size; ++minor) {                                        
40002590:   c6 07 20 04     ld  [ %i4 + 4 ], %g3                                          
40002594:   80 a0 e0 00     cmp  %g3, 0                                                   
40002598:   02 80 00 10     be  400025d8 <rtems_disk_io_done+0x74>                        
4000259c:   c4 07 40 01     ld  [ %i5 + %g1 ], %g2                                        
400025a0:   ba 10 20 00     clr  %i5                                                      
      rtems_disk_device *dd = dtab->minor [minor];                                        
400025a4:   83 2f 60 02     sll  %i5, 2, %g1                                              
400025a8:   d0 00 80 01     ld  [ %g2 + %g1 ], %o0                                        
                                                                                          
      if (dd != NULL) {                                                                   
400025ac:   80 a2 20 00     cmp  %o0, 0                                                   
400025b0:   02 80 00 06     be  400025c8 <rtems_disk_io_done+0x64>                        <== ALWAYS TAKEN
400025b4:   ba 07 60 01     inc  %i5                                                      
        free_disk_device(dd);                                                             
400025b8:   7f ff fe 81     call  40001fbc <free_disk_device>                             <== NOT EXECUTED
400025bc:   01 00 00 00     nop                                                           <== NOT EXECUTED
400025c0:   c6 07 20 04     ld  [ %i4 + 4 ], %g3                                          <== NOT EXECUTED
      }                                                                                   
    }                                                                                     
    free(dtab->minor);                                                                    
400025c4:   c4 07 00 00     ld  [ %i4 ], %g2                                              <== NOT EXECUTED
    for (minor = 0; minor < dtab->size; ++minor) {                                        
400025c8:   80 a0 c0 1d     cmp  %g3, %i5                                                 
400025cc:   18 bf ff f7     bgu  400025a8 <rtems_disk_io_done+0x44>                       
400025d0:   83 2f 60 02     sll  %i5, 2, %g1                                              
  }                                                                                       
  free(disktab);                                                                          
400025d4:   fa 06 a2 84     ld  [ %i2 + 0x284 ], %i5                                      
    free(dtab->minor);                                                                    
400025d8:   40 00 01 54     call  40002b28 <free>                                         
400025dc:   90 10 00 02     mov  %g2, %o0                                                 
  for (major = 0; major < disktab_size; ++major) {                                        
400025e0:   c2 06 40 00     ld  [ %i1 ], %g1                                              
400025e4:   b6 06 e0 01     inc  %i3                                                      
400025e8:   80 a0 40 1b     cmp  %g1, %i3                                                 
400025ec:   18 bf ff e8     bgu  4000258c <rtems_disk_io_done+0x28>                       
400025f0:   83 2e e0 03     sll  %i3, 3, %g1                                              
  free(disktab);                                                                          
400025f4:   90 10 00 1d     mov  %i5, %o0                                                 
400025f8:   40 00 01 4c     call  40002b28 <free>                                         
400025fc:   b0 10 20 00     clr  %i0                                                      
                                                                                          
  disktab = NULL;                                                                         
40002600:   c0 26 a2 84     clr  [ %i2 + 0x284 ]                                          
  disktab_size = 0;                                                                       
40002604:   c0 24 22 80     clr  [ %l0 + 0x280 ]                                          
                                                                                          
  return RTEMS_SUCCESSFUL;                                                                
}                                                                                         
40002608:   81 c7 e0 08     ret                                                           
4000260c:   81 e8 00 00     restore                                                       
                                                                                          
===============================================================================
400024f8 <rtems_disk_io_initialize>:                                                      
  }                                                                                       
}                                                                                         
                                                                                          
rtems_status_code                                                                         
rtems_disk_io_initialize(void)                                                            
{                                                                                         
400024f8:   9d e3 bf a0     save  %sp, -96, %sp                                           
  rtems_status_code sc = RTEMS_SUCCESSFUL;                                                
  rtems_device_major_number size = DISKTAB_INITIAL_SIZE;                                  
                                                                                          
  if (disktab_size > 0) {                                                                 
400024fc:   3b 10 00 61     sethi  %hi(0x40018400), %i5                                   
40002500:   c2 07 62 80     ld  [ %i5 + 0x280 ], %g1    ! 40018680 <disktab_size>         
40002504:   80 a0 60 00     cmp  %g1, 0                                                   
40002508:   12 80 00 0f     bne  40002544 <rtems_disk_io_initialize+0x4c>                 <== NEVER TAKEN
4000250c:   b0 10 20 00     clr  %i0                                                      
    return RTEMS_SUCCESSFUL;                                                              
  }                                                                                       
                                                                                          
  disktab = calloc(size, sizeof(rtems_disk_device_table));                                
40002510:   92 10 20 08     mov  8, %o1                                                   
40002514:   90 10 20 08     mov  8, %o0                                                   
40002518:   40 00 01 1a     call  40002980 <calloc>                                       
4000251c:   39 10 00 61     sethi  %hi(0x40018400), %i4                                   
  if (disktab == NULL) {                                                                  
40002520:   80 a2 20 00     cmp  %o0, 0                                                   
40002524:   02 80 00 0e     be  4000255c <rtems_disk_io_initialize+0x64>                  <== NEVER TAKEN
40002528:   d0 27 22 84     st  %o0, [ %i4 + 0x284 ]                                      
    return RTEMS_NO_MEMORY;                                                               
  }                                                                                       
                                                                                          
  sc = rtems_bdbuf_init();                                                                
4000252c:   40 00 27 90     call  4000c36c <rtems_bdbuf_init>                             
40002530:   01 00 00 00     nop                                                           
  if (sc != RTEMS_SUCCESSFUL) {                                                           
40002534:   b0 92 20 00     orcc  %o0, 0, %i0                                             
40002538:   12 80 00 05     bne  4000254c <rtems_disk_io_initialize+0x54>                 <== NEVER TAKEN
4000253c:   82 10 20 08     mov  8, %g1                                                   
    free(disktab);                                                                        
                                                                                          
    return RTEMS_UNSATISFIED;                                                             
  }                                                                                       
                                                                                          
  disktab_size = size;                                                                    
40002540:   c2 27 62 80     st  %g1, [ %i5 + 0x280 ]                                      
                                                                                          
  return RTEMS_SUCCESSFUL;                                                                
40002544:   81 c7 e0 08     ret                                                           
40002548:   81 e8 00 00     restore                                                       
    free(disktab);                                                                        
4000254c:   40 00 01 77     call  40002b28 <free>                                         <== NOT EXECUTED
40002550:   d0 07 22 84     ld  [ %i4 + 0x284 ], %o0                                      <== NOT EXECUTED
    return RTEMS_UNSATISFIED;                                                             
40002554:   81 c7 e0 08     ret                                                           <== NOT EXECUTED
40002558:   91 e8 20 0d     restore  %g0, 0xd, %o0                                        <== NOT EXECUTED
}                                                                                         
4000255c:   81 c7 e0 08     ret                                                           <== NOT EXECUTED
40002560:   91 e8 20 1a     restore  %g0, 0x1a, %o0                                       <== NOT EXECUTED
                                                                                          
===============================================================================
400023e0 <rtems_disk_obtain>:                                                             
                                                                                          
rtems_disk_device *                                                                       
rtems_disk_obtain(dev_t dev)                                                              
{                                                                                         
400023e0:   9d e3 bf 98     save  %sp, -104, %sp                                          
 * @return This method returns the entire PSR contents.                                   
 */                                                                                       
static inline uint32_t sparc_disable_interrupts(void)                                     
{                                                                                         
  register uint32_t psr __asm__("g1"); /* return value of trap handler */                 
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));               
400023e4:   91 d0 20 09     ta  9                                                         
  return psr;                                                                             
400023e8:   c2 27 bf fc     st  %g1, [ %fp + -4 ]                                         
  rtems_disk_device *dd = NULL;                                                           
  rtems_interrupt_lock_context lock_context;                                              
                                                                                          
  rtems_interrupt_lock_acquire(&diskdevs_lock, &lock_context);                            
  if (!diskdevs_protected) {                                                              
400023ec:   3b 10 00 61     sethi  %hi(0x40018400), %i5                                   
400023f0:   c4 0f 62 7c     ldub  [ %i5 + 0x27c ], %g2  ! 4001867c <diskdevs_protected>   
400023f4:   80 a0 a0 00     cmp  %g2, 0                                                   
400023f8:   12 80 00 0b     bne  40002424 <rtems_disk_obtain+0x44>                        <== NEVER TAKEN
400023fc:   94 10 20 00     clr  %o2                                                      
    /* Frequent and quickest case */                                                      
    dd = get_disk_entry(dev, false);                                                      
40002400:   90 10 00 18     mov  %i0, %o0                                                 
40002404:   7f ff fe 58     call  40001d64 <get_disk_entry>                               
40002408:   92 10 00 19     mov  %i1, %o1                                                 
4000240c:   b0 10 00 08     mov  %o0, %i0                                                 
 *                                                                                        
 * @param[in] psr is the PSR returned by @ref sparc_disable_interrupts.                   
 */                                                                                       
static inline void sparc_enable_interrupts(uint32_t psr)                                  
{                                                                                         
  register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */                 
40002410:   c2 07 bf fc     ld  [ %fp + -4 ], %g1                                         
   * The trap instruction has a higher trap priority than the interrupts                  
   * according to "The SPARC Architecture Manual: Version 8", Table 7-1                   
   * "Exception and Interrupt Request Priority and tt Values".  Add a nop to              
   * prevent a trap instruction right after the interrupt enable trap.                    
   */                                                                                     
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));             
40002414:   91 d0 20 0a     ta  0xa                                                       
40002418:   01 00 00 00     nop                                                           
}                                                                                         
4000241c:   81 c7 e0 08     ret                                                           
40002420:   81 e8 00 00     restore                                                       
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));             
40002424:   91 d0 20 0a     ta  0xa                                                       <== NOT EXECUTED
40002428:   01 00 00 00     nop                                                           <== NOT EXECUTED
  _Mutex_Acquire( mutex );                                                                
4000242c:   39 10 00 59     sethi  %hi(0x40016400), %i4                                   <== NOT EXECUTED
40002430:   40 00 13 88     call  40007250 <_Mutex_Acquire>                               <== NOT EXECUTED
40002434:   90 17 23 fc     or  %i4, 0x3fc, %o0 ! 400167fc <diskdevs_mutex>               <== NOT EXECUTED
  diskdevs_protected = true;                                                              
40002438:   82 10 20 01     mov  1, %g1                                                   <== NOT EXECUTED
    rtems_interrupt_lock_release(&diskdevs_lock, &lock_context);                          
  } else {                                                                                
    rtems_interrupt_lock_release(&diskdevs_lock, &lock_context);                          
                                                                                          
    disk_lock();                                                                          
    dd = get_disk_entry(dev, false);                                                      
4000243c:   94 10 20 00     clr  %o2                                                      <== NOT EXECUTED
  diskdevs_protected = true;                                                              
40002440:   c2 2f 62 7c     stb  %g1, [ %i5 + 0x27c ]                                     <== NOT EXECUTED
    dd = get_disk_entry(dev, false);                                                      
40002444:   90 10 00 18     mov  %i0, %o0                                                 <== NOT EXECUTED
40002448:   7f ff fe 47     call  40001d64 <get_disk_entry>                               <== NOT EXECUTED
4000244c:   92 10 00 19     mov  %i1, %o1                                                 <== NOT EXECUTED
  diskdevs_protected = false;                                                             
40002450:   c0 2f 62 7c     clrb  [ %i5 + 0x27c ]                                         <== NOT EXECUTED
    dd = get_disk_entry(dev, false);                                                      
40002454:   b0 10 00 08     mov  %o0, %i0                                                 <== NOT EXECUTED
  _Mutex_Release( mutex );                                                                
40002458:   40 00 13 99     call  400072bc <_Mutex_Release>                               <== NOT EXECUTED
4000245c:   90 17 23 fc     or  %i4, 0x3fc, %o0                                           <== NOT EXECUTED
    disk_unlock();                                                                        
  }                                                                                       
                                                                                          
  return dd;                                                                              
}                                                                                         
40002460:   81 c7 e0 08     ret                                                           <== NOT EXECUTED
40002464:   81 e8 00 00     restore                                                       <== NOT EXECUTED
                                                                                          
===============================================================================
40002468 <rtems_disk_release>:                                                            
                                                                                          
rtems_status_code                                                                         
rtems_disk_release(rtems_disk_device *dd)                                                 
{                                                                                         
40002468:   9d e3 bf a0     save  %sp, -96, %sp                                           
  rtems_interrupt_lock_context lock_context;                                              
  dev_t dev = dd->dev;                                                                    
4000246c:   f8 1e 00 00     ldd  [ %i0 ], %i4                                             
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));               
40002470:   91 d0 20 09     ta  9                                                         
  unsigned uses = 0;                                                                      
  bool deleted = false;                                                                   
                                                                                          
  rtems_interrupt_lock_acquire(&diskdevs_lock, &lock_context);                            
  uses = --dd->uses;                                                                      
40002474:   c4 06 20 14     ld  [ %i0 + 0x14 ], %g2                                       
40002478:   84 00 bf ff     add  %g2, -1, %g2                                             
  deleted = dd->deleted;                                                                  
4000247c:   c6 0e 20 40     ldub  [ %i0 + 0x40 ], %g3                                     
  uses = --dd->uses;                                                                      
40002480:   c4 26 20 14     st  %g2, [ %i0 + 0x14 ]                                       
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));             
40002484:   91 d0 20 0a     ta  0xa                                                       
40002488:   01 00 00 00     nop                                                           
  rtems_interrupt_lock_release(&diskdevs_lock, &lock_context);                            
                                                                                          
  if (uses == 0 && deleted) {                                                             
4000248c:   80 a0 a0 00     cmp  %g2, 0                                                   
40002490:   12 80 00 04     bne  400024a0 <rtems_disk_release+0x38>                       
40002494:   80 88 e0 ff     btst  0xff, %g3                                               
40002498:   12 80 00 04     bne  400024a8 <rtems_disk_release+0x40>                       
4000249c:   37 10 00 59     sethi  %hi(0x40016400), %i3                                   
    rtems_disk_delete(dev);                                                               
  }                                                                                       
                                                                                          
  return RTEMS_SUCCESSFUL;                                                                
}                                                                                         
400024a0:   81 c7 e0 08     ret                                                           
400024a4:   91 e8 20 00     restore  %g0, 0, %o0                                          
  _Mutex_Acquire( mutex );                                                                
400024a8:   40 00 13 6a     call  40007250 <_Mutex_Acquire>                               
400024ac:   90 16 e3 fc     or  %i3, 0x3fc, %o0                                           
  diskdevs_protected = true;                                                              
400024b0:   35 10 00 61     sethi  %hi(0x40018400), %i2                                   
400024b4:   b2 10 20 01     mov  1, %i1                                                   
  dd = get_disk_entry(dev, true);                                                         
400024b8:   94 10 20 01     mov  1, %o2                                                   
  diskdevs_protected = true;                                                              
400024bc:   f2 2e a2 7c     stb  %i1, [ %i2 + 0x27c ]                                     
  dd = get_disk_entry(dev, true);                                                         
400024c0:   90 10 00 1c     mov  %i4, %o0                                                 
400024c4:   7f ff fe 28     call  40001d64 <get_disk_entry>                               
400024c8:   92 10 00 1d     mov  %i5, %o1                                                 
  if (dd == NULL) {                                                                       
400024cc:   82 92 20 00     orcc  %o0, 0, %g1                                             
400024d0:   02 80 00 04     be  400024e0 <rtems_disk_release+0x78>                        <== NEVER TAKEN
400024d4:   01 00 00 00     nop                                                           
  rtems_disk_cleanup(dd);                                                                 
400024d8:   7f ff fe cf     call  40002014 <rtems_disk_cleanup.constprop.0>               
400024dc:   f2 28 60 40     stb  %i1, [ %g1 + 0x40 ]                                      
  diskdevs_protected = false;                                                             
400024e0:   c0 2e a2 7c     clrb  [ %i2 + 0x27c ]                                         
  _Mutex_Release( mutex );                                                                
400024e4:   90 16 e3 fc     or  %i3, 0x3fc, %o0                                           
400024e8:   40 00 13 75     call  400072bc <_Mutex_Release>                               
400024ec:   b0 10 20 00     clr  %i0                                                      
}                                                                                         
400024f0:   81 c7 e0 08     ret                                                           
400024f4:   81 e8 00 00     restore                                                       
                                                                                          
===============================================================================
40005240 <rtems_fdisk_initialize>:                                                        
 */                                                                                       
rtems_device_driver                                                                       
rtems_fdisk_initialize (rtems_device_major_number major,                                  
                        rtems_device_minor_number minor,                                  
                        void*                     arg RTEMS_UNUSED)                       
{                                                                                         
40005240:   9d e3 bf 88     save  %sp, -120, %sp                                          
  rtems_fdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);                            
40005244:   40 00 03 41     call  40005f48 <malloc>                                       
40005248:   90 10 22 00     mov  0x200, %o0                                               
4000524c:   03 10 01 15     sethi  %hi(0x40045400), %g1                                   
40005250:   d0 20 62 38     st  %o0, [ %g1 + 0x238 ]    ! 40045638 <rtems_fdisk_crc16_factor>
      v = v & 1 ? (v >> 1) ^ pattern : v >> 1;                                            
40005254:   09 3f ff e1     sethi  %hi(0xffff8400), %g4                                   
  for (b = 0; b < 256; b++)                                                               
40005258:   86 10 20 00     clr  %g3                                                      
  if (!rtems_fdisk_crc16_factor)                                                          
4000525c:   80 a2 20 00     cmp  %o0, 0                                                   
40005260:   02 80 01 14     be  400056b0 <rtems_fdisk_initialize+0x470>                   <== NEVER TAKEN
40005264:   88 11 20 08     or  %g4, 8, %g4                                               
    uint16_t v = b;                                                                       
40005268:   82 10 00 03     mov  %g3, %g1                                                 
  for (b = 0; b < 256; b++)                                                               
4000526c:   ae 10 20 08     mov  8, %l7                                                   
      v = v & 1 ? (v >> 1) ^ pattern : v >> 1;                                            
40005270:   84 08 60 01     and  %g1, 1, %g2                                              
40005274:   83 28 60 10     sll  %g1, 0x10, %g1                                           
40005278:   80 a0 a0 00     cmp  %g2, 0                                                   
4000527c:   85 30 60 11     srl  %g1, 0x11, %g2                                           
40005280:   02 80 00 03     be  4000528c <rtems_fdisk_initialize+0x4c>                    
40005284:   82 10 00 02     mov  %g2, %g1                                                 
40005288:   82 18 80 04     xor  %g2, %g4, %g1                                            
    for (i = 8; i--;)                                                                     
4000528c:   ae 85 ff ff     addcc  %l7, -1, %l7                                           
40005290:   12 bf ff f9     bne  40005274 <rtems_fdisk_initialize+0x34>                   
40005294:   84 08 60 01     and  %g1, 1, %g2                                              
    rtems_fdisk_crc16_factor[b] = v & 0xffff;                                             
40005298:   85 28 e0 01     sll  %g3, 1, %g2                                              
  for (b = 0; b < 256; b++)                                                               
4000529c:   86 00 e0 01     inc  %g3                                                      
400052a0:   80 a0 e1 00     cmp  %g3, 0x100                                               
400052a4:   12 bf ff f1     bne  40005268 <rtems_fdisk_initialize+0x28>                   
400052a8:   c2 32 00 02     sth  %g1, [ %o0 + %g2 ]                                       
                                                                                          
  sc = rtems_fdisk_crc16_gen_factors (0x8408);                                            
  if (sc != RTEMS_SUCCESSFUL)                                                             
      return sc;                                                                          
                                                                                          
  fd = calloc (rtems_flashdisk_configuration_size, sizeof (*fd));                         
400052ac:   2b 10 00 cc     sethi  %hi(0x40033000), %l5                                   
400052b0:   fa 05 61 94     ld  [ %l5 + 0x194 ], %i5    ! 40033194 <rtems_flashdisk_configuration_size>
400052b4:   92 10 20 84     mov  0x84, %o1                                                
400052b8:   40 00 01 33     call  40005784 <calloc>                                       
400052bc:   90 10 00 1d     mov  %i5, %o0                                                 
  if (!fd)                                                                                
400052c0:   b8 92 20 00     orcc  %o0, 0, %i4                                             
400052c4:   02 80 00 fb     be  400056b0 <rtems_fdisk_initialize+0x470>                   <== NEVER TAKEN
400052c8:   80 a7 60 00     cmp  %i5, 0                                                   
    return RTEMS_NO_MEMORY;                                                               
                                                                                          
  for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++, fd++)         
400052cc:   02 80 00 b6     be  400055a4 <rtems_fdisk_initialize+0x364>                   <== NEVER TAKEN
400052d0:   29 00 00 18     sethi  %hi(0x6000), %l4                                       
  {                                                                                       
    char     name[] = RTEMS_FLASHDISK_DEVICE_BASE_NAME "a";                               
400052d4:   82 15 21 00     or  %l4, 0x100, %g1 ! 6100 <_ISR_Stack_size+0x5100>           
static __inline void                                                                      
_Mutex_Initialize_named(struct _Mutex_Control *_mutex, const char *_name)                 
{                                                                                         
    struct _Mutex_Control _init = _MUTEX_NAMED_INITIALIZER(_name);                        
                                                                                          
    *_mutex = _init;                                                                      
400052d8:   27 10 00 b4     sethi  %hi(0x4002d000), %l3                                   
400052dc:   c2 37 bf ee     sth  %g1, [ %fp + -18 ]                                       
400052e0:   82 14 e1 f0     or  %l3, 0x1f0, %g1                                           
400052e4:   c2 27 bf e8     st  %g1, [ %fp + -24 ]                                        
  const rtems_flashdisk_config* c = rtems_flashdisk_configuration;                        
400052e8:   35 10 00 b0     sethi  %hi(0x4002c000), %i2                                   
    if (!fd->devices)                                                                     
      return RTEMS_NO_MEMORY;                                                             
                                                                                          
    rtems_mutex_init (&fd->lock, "Flash Disk");                                           
                                                                                          
    sc = rtems_blkdev_create(name, c->block_size, blocks - fd->unavail_blocks,            
400052ec:   25 10 00 0f     sethi  %hi(0x40003c00), %l2                                   
  for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++, fd++)         
400052f0:   b2 10 20 00     clr  %i1                                                      
  const rtems_flashdisk_config* c = rtems_flashdisk_configuration;                        
400052f4:   b4 16 a2 64     or  %i2, 0x264, %i2                                           
    sc = rtems_blkdev_create(name, c->block_size, blocks - fd->unavail_blocks,            
400052f8:   a4 14 a1 b8     or  %l2, 0x1b8, %l2                                           
    char     name[] = RTEMS_FLASHDISK_DEVICE_BASE_NAME "a";                               
400052fc:   c2 17 bf ee     lduh  [ %fp + -18 ], %g1                                      
40005300:   c2 37 bf f8     sth  %g1, [ %fp + -8 ]                                        
40005304:   19 0b d9 19     sethi  %hi(0x2f646400), %o4                                   
    fd->flags              = c->flags;                                                    
40005308:   c8 06 a0 0c     ld  [ %i2 + 0xc ], %g4                                        
    fd->compact_segs       = c->compact_segs;                                             
4000530c:   c6 06 a0 14     ld  [ %i2 + 0x14 ], %g3                                       
    fd->avail_compact_segs = c->avail_compact_segs;                                       
40005310:   c4 06 a0 18     ld  [ %i2 + 0x18 ], %g2                                       
    fd->block_size         = c->block_size;                                               
40005314:   f6 06 80 00     ld  [ %i2 ], %i3                                              
    fd->unavail_blocks     = c->unavail_blocks;                                           
40005318:   fa 06 a0 10     ld  [ %i2 + 0x10 ], %i5                                       
    fd->info_level         = c->info_level;                                               
4000531c:   c2 06 a0 1c     ld  [ %i2 + 0x1c ], %g1                                       
    char     name[] = RTEMS_FLASHDISK_DEVICE_BASE_NAME "a";                               
40005320:   98 13 21 76     or  %o4, 0x176, %o4                                           
40005324:   1b 0b d9 99     sethi  %hi(0x2f666400), %o5                                   
    name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;                             
40005328:   f2 2f bf f9     stb  %i1, [ %fp + -7 ]                                        
    char     name[] = RTEMS_FLASHDISK_DEVICE_BASE_NAME "a";                               
4000532c:   9a 13 60 64     or  %o5, 0x64, %o5                                            
    fd->major              = major;                                                       
40005330:   f0 27 00 00     st  %i0, [ %i4 ]                                              
    char     name[] = RTEMS_FLASHDISK_DEVICE_BASE_NAME "a";                               
40005334:   d8 3f bf f0     std  %o4, [ %fp + -16 ]                                       
    fd->minor              = minor;                                                       
40005338:   f2 27 20 04     st  %i1, [ %i4 + 4 ]                                          
    fd->flags              = c->flags;                                                    
4000533c:   c8 27 20 08     st  %g4, [ %i4 + 8 ]                                          
    fd->compact_segs       = c->compact_segs;                                             
40005340:   c6 27 20 0c     st  %g3, [ %i4 + 0xc ]                                        
    fd->avail_compact_segs = c->avail_compact_segs;                                       
40005344:   c4 27 20 10     st  %g2, [ %i4 + 0x10 ]                                       
    fd->block_size         = c->block_size;                                               
40005348:   f6 27 20 14     st  %i3, [ %i4 + 0x14 ]                                       
    fd->unavail_blocks     = c->unavail_blocks;                                           
4000534c:   fa 27 20 20     st  %i5, [ %i4 + 0x20 ]                                       
    fd->info_level         = c->info_level;                                               
40005350:   c2 27 20 7c     st  %g1, [ %i4 + 0x7c ]                                       
    for (device = 0; device < c->device_count; device++)                                  
40005354:   e0 06 a0 04     ld  [ %i2 + 4 ], %l0                                          
40005358:   80 a4 20 00     cmp  %l0, 0                                                   
4000535c:   02 80 00 a6     be  400055f4 <rtems_fdisk_initialize+0x3b4>                   <== NEVER TAKEN
40005360:   95 2c 20 01     sll  %l0, 1, %o2                                              
40005364:   d6 06 a0 08     ld  [ %i2 + 8 ], %o3                                          
    uint32_t blocks = 0;                                                                  
40005368:   ac 10 20 00     clr  %l6                                                      
4000536c:   94 02 80 10     add  %o2, %l0, %o2                                            
40005370:   95 2a a0 02     sll  %o2, 2, %o2                                              
40005374:   94 02 80 0b     add  %o2, %o3, %o2                                            
  for (s = 0; s < dd->segment_count; s++)                                                 
40005378:   c2 02 c0 00     ld  [ %o3 ], %g1                                              
4000537c:   80 a0 60 00     cmp  %g1, 0                                                   
40005380:   02 80 00 1c     be  400053f0 <rtems_fdisk_initialize+0x1b0>                   <== NEVER TAKEN
40005384:   88 10 20 00     clr  %g4                                                      
40005388:   c6 02 e0 04     ld  [ %o3 + 4 ], %g3                                          
4000538c:   99 28 60 01     sll  %g1, 1, %o4                                              
40005390:   98 03 00 01     add  %o4, %g1, %o4                                            
40005394:   99 2b 20 02     sll  %o4, 2, %o4                                              
40005398:   98 03 00 03     add  %o4, %g3, %o4                                            
       rtems_fdisk_page_desc_pages (sd, page_size)) * sd->count;                          
4000539c:   de 10 c0 00     lduh  [ %g3 ], %o7                                            
  return sd->size / page_size;                                                            
400053a0:   81 80 20 00     wr  %g0, %y                                                   
400053a4:   c2 00 e0 08     ld  [ %g3 + 8 ], %g1                                          
400053a8:   01 00 00 00     nop                                                           
400053ac:   01 00 00 00     nop                                                           
400053b0:   82 70 40 1b     udiv  %g1, %i3, %g1                                           
  for (s = 0; s < dd->segment_count; s++)                                                 
400053b4:   86 00 e0 0c     add  %g3, 0xc, %g3                                            
      (rtems_fdisk_pages_in_segment (sd, page_size) -                                     
400053b8:   84 00 7f ff     add  %g1, -1, %g2                                             
  for (s = 0; s < dd->segment_count; s++)                                                 
400053bc:   80 a3 00 03     cmp  %o4, %g3                                                 
  uint32_t bytes = pages * sizeof (rtems_fdisk_page_desc);                                
400053c0:   83 28 60 03     sll  %g1, 3, %g1                                              
  return ((bytes - 1) / page_size) + 1;                                                   
400053c4:   82 00 7f ff     add  %g1, -1, %g1                                             
400053c8:   81 80 20 00     wr  %g0, %y                                                   
400053cc:   01 00 00 00     nop                                                           
400053d0:   01 00 00 00     nop                                                           
400053d4:   01 00 00 00     nop                                                           
400053d8:   82 70 40 1b     udiv  %g1, %i3, %g1                                           
      (rtems_fdisk_pages_in_segment (sd, page_size) -                                     
400053dc:   82 20 80 01     sub  %g2, %g1, %g1                                            
       rtems_fdisk_page_desc_pages (sd, page_size)) * sd->count;                          
400053e0:   9e 58 40 0f     smul  %g1, %o7, %o7                                           
  for (s = 0; s < dd->segment_count; s++)                                                 
400053e4:   12 bf ff ee     bne  4000539c <rtems_fdisk_initialize+0x15c>                  <== NEVER TAKEN
400053e8:   88 01 00 0f     add  %g4, %o7, %g4                                            
      blocks += rtems_fdisk_blocks_in_device (&c->devices[device],                        
400053ec:   ac 05 80 04     add  %l6, %g4, %l6                                            
    for (device = 0; device < c->device_count; device++)                                  
400053f0:   96 02 e0 0c     add  %o3, 0xc, %o3                                            
400053f4:   80 a2 c0 0a     cmp  %o3, %o2                                                 
400053f8:   32 bf ff e1     bne,a   4000537c <rtems_fdisk_initialize+0x13c>               <== NEVER TAKEN
400053fc:   c2 02 c0 00     ld  [ %o3 ], %g1                                              <== NOT EXECUTED
    fd->copy_buffer = malloc (c->block_size);                                             
40005400:   40 00 02 d2     call  40005f48 <malloc>                                       
40005404:   90 10 00 1b     mov  %i3, %o0                                                 
    if (!fd->copy_buffer)                                                                 
40005408:   80 a2 20 00     cmp  %o0, 0                                                   
4000540c:   02 80 00 ab     be  400056b8 <rtems_fdisk_initialize+0x478>                   <== NEVER TAKEN
40005410:   d0 27 20 78     st  %o0, [ %i4 + 0x78 ]                                       
    fd->blocks = calloc (blocks, sizeof (rtems_fdisk_block_ctl));                         
40005414:   92 10 20 08     mov  8, %o1                                                   
40005418:   40 00 00 db     call  40005784 <calloc>                                       
4000541c:   90 10 00 16     mov  %l6, %o0                                                 
    if (!fd->blocks)                                                                      
40005420:   80 a2 20 00     cmp  %o0, 0                                                   
40005424:   02 80 00 a5     be  400056b8 <rtems_fdisk_initialize+0x478>                   <== NEVER TAKEN
40005428:   d0 27 20 18     st  %o0, [ %i4 + 0x18 ]                                       
    fd->block_count = blocks;                                                             
4000542c:   ec 27 20 1c     st  %l6, [ %i4 + 0x1c ]                                       
    fd->devices = calloc (c->device_count, sizeof (rtems_fdisk_device_ctl));              
40005430:   92 10 20 0c     mov  0xc, %o1                                                 
40005434:   40 00 00 d4     call  40005784 <calloc>                                       
40005438:   90 10 00 10     mov  %l0, %o0                                                 
    if (!fd->devices)                                                                     
4000543c:   80 a2 20 00     cmp  %o0, 0                                                   
40005440:   02 80 00 9e     be  400056b8 <rtems_fdisk_initialize+0x478>                   <== NEVER TAKEN
40005444:   d0 27 20 2c     st  %o0, [ %i4 + 0x2c ]                                       
40005448:   c2 07 bf e8     ld  [ %fp + -24 ], %g1                                        
4000544c:   c0 27 20 64     clr  [ %i4 + 0x64 ]                                           
    sc = rtems_blkdev_create(name, c->block_size, blocks - fd->unavail_blocks,            
40005450:   94 25 80 1d     sub  %l6, %i5, %o2                                            
40005454:   c0 27 20 68     clr  [ %i4 + 0x68 ]                                           
40005458:   98 10 00 1c     mov  %i4, %o4                                                 
4000545c:   c0 27 20 6c     clr  [ %i4 + 0x6c ]                                           
40005460:   96 10 00 12     mov  %l2, %o3                                                 
40005464:   c0 27 20 70     clr  [ %i4 + 0x70 ]                                           
40005468:   92 10 00 1b     mov  %i3, %o1                                                 
4000546c:   c2 27 20 74     st  %g1, [ %i4 + 0x74 ]                                       
40005470:   40 00 32 3f     call  40011d6c <rtems_blkdev_create>                          
40005474:   90 07 bf f0     add  %fp, -16, %o0                                            
                             rtems_fdisk_ioctl, fd);                                      
    if (sc != RTEMS_SUCCESSFUL)                                                           
40005478:   ba 92 20 00     orcc  %o0, 0, %i5                                             
4000547c:   12 80 00 60     bne  400055fc <rtems_fdisk_initialize+0x3bc>                  <== NEVER TAKEN
40005480:   01 00 00 00     nop                                                           
      free (fd->devices);                                                                 
      rtems_fdisk_error ("disk create phy failed");                                       
      return sc;                                                                          
    }                                                                                     
                                                                                          
    for (device = 0; device < c->device_count; device++)                                  
40005484:   f6 06 a0 04     ld  [ %i2 + 4 ], %i3                                          
40005488:   80 a6 e0 00     cmp  %i3, 0                                                   
4000548c:   22 80 00 37     be,a   40005568 <rtems_fdisk_initialize+0x328>                <== NEVER TAKEN
40005490:   f6 27 20 30     st  %i3, [ %i4 + 0x30 ]                                       <== NOT EXECUTED
40005494:   e2 06 a0 08     ld  [ %i2 + 8 ], %l1                                          
40005498:   e0 07 20 2c     ld  [ %i4 + 0x2c ], %l0                                       
4000549c:   ac 10 20 00     clr  %l6                                                      
  for (segment = 0; segment < dd->segment_count; segment++)                               
400054a0:   e6 04 40 00     ld  [ %l1 ], %l3                                              
400054a4:   80 a4 e0 00     cmp  %l3, 0                                                   
400054a8:   02 80 00 41     be  400055ac <rtems_fdisk_initialize+0x36c>                   <== NEVER TAKEN
400054ac:   9b 2c e0 01     sll  %l3, 1, %o5                                              
400054b0:   fa 04 60 04     ld  [ %l1 + 4 ], %i5                                          
    count += dd->segments[segment].count;                                                 
400054b4:   82 10 00 1d     mov  %i5, %g1                                                 
400054b8:   9a 03 40 13     add  %o5, %l3, %o5                                            
  uint32_t count = 0;                                                                     
400054bc:   a6 10 20 00     clr  %l3                                                      
400054c0:   9b 2b 60 02     sll  %o5, 2, %o5                                              
400054c4:   a8 03 40 1d     add  %o5, %i5, %l4                                            
    count += dd->segments[segment].count;                                                 
400054c8:   c4 10 40 00     lduh  [ %g1 ], %g2                                            
  for (segment = 0; segment < dd->segment_count; segment++)                               
400054cc:   82 00 60 0c     add  %g1, 0xc, %g1                                            
400054d0:   80 a5 00 01     cmp  %l4, %g1                                                 
400054d4:   12 bf ff fd     bne  400054c8 <rtems_fdisk_initialize+0x288>                  <== NEVER TAKEN
400054d8:   a6 04 c0 02     add  %l3, %g2, %l3                                            
      uint32_t                 segment_count;                                             
      uint32_t                 segment;                                                   
                                                                                          
      segment_count = rtems_fdisk_count_segments (&c->devices[device]);                   
                                                                                          
      fd->devices[device].segments = calloc (segment_count,                               
400054dc:   92 10 20 30     mov  0x30, %o1                                                
400054e0:   40 00 00 a9     call  40005784 <calloc>                                       
400054e4:   90 10 00 13     mov  %l3, %o0                                                 
                                             sizeof (rtems_fdisk_segment_ctl));           
      if (!fd->devices[device].segments)                                                  
400054e8:   80 a2 20 00     cmp  %o0, 0                                                   
400054ec:   02 80 00 36     be  400055c4 <rtems_fdisk_initialize+0x384>                   <== NEVER TAKEN
400054f0:   d0 24 00 00     st  %o0, [ %l0 ]                                              
        const rtems_fdisk_segment_desc* sd;                                               
        uint32_t                        seg_segment;                                      
                                                                                          
        sd = &c->devices[device].segments[segment];                                       
                                                                                          
        for (seg_segment = 0; seg_segment < sd->count; seg_segment++, sc++)               
400054f4:   c6 17 40 00     lduh  [ %i5 ], %g3                                            
400054f8:   80 a0 e0 00     cmp  %g3, 0                                                   
400054fc:   02 80 00 0f     be  40005538 <rtems_fdisk_initialize+0x2f8>                   <== NEVER TAKEN
40005500:   84 10 20 00     clr  %g2                                                      
40005504:   82 10 00 08     mov  %o0, %g1                                                 
        {                                                                                 
          sc->descriptor = sd;                                                            
          sc->device     = device;                                                        
          sc->segment    = seg_segment;                                                   
40005508:   c4 20 60 0c     st  %g2, [ %g1 + 0xc ]                                        
        for (seg_segment = 0; seg_segment < sd->count; seg_segment++, sc++)               
4000550c:   82 00 60 30     add  %g1, 0x30, %g1                                           
          sc->descriptor = sd;                                                            
40005510:   fa 20 7f d4     st  %i5, [ %g1 + -44 ]                                        
        for (seg_segment = 0; seg_segment < sd->count; seg_segment++, sc++)               
40005514:   84 00 a0 01     inc  %g2                                                      
          sc->device     = device;                                                        
40005518:   ec 20 7f d8     st  %l6, [ %g1 + -40 ]                                        
        for (seg_segment = 0; seg_segment < sd->count; seg_segment++, sc++)               
4000551c:   80 a0 80 03     cmp  %g2, %g3                                                 
40005520:   12 bf ff fa     bne  40005508 <rtems_fdisk_initialize+0x2c8>                  
40005524:   c0 20 7f fc     clr  [ %g1 + -4 ]                                             
40005528:   83 28 a0 01     sll  %g2, 1, %g1                                              
4000552c:   84 00 40 02     add  %g1, %g2, %g2                                            
40005530:   85 28 a0 04     sll  %g2, 4, %g2                                              
40005534:   90 02 00 02     add  %o0, %g2, %o0                                            
      for (segment = 0; segment < c->devices[device].segment_count; segment++)            
40005538:   ba 07 60 0c     add  %i5, 0xc, %i5                                            
4000553c:   80 a5 00 1d     cmp  %l4, %i5                                                 
40005540:   32 bf ff ee     bne,a   400054f8 <rtems_fdisk_initialize+0x2b8>               <== NEVER TAKEN
40005544:   c6 17 40 00     lduh  [ %i5 ], %g3                                            <== NOT EXECUTED
          sc->erased     = 0;                                                             
        }                                                                                 
      }                                                                                   
                                                                                          
      fd->devices[device].segment_count = segment_count;                                  
      fd->devices[device].descriptor    = &c->devices[device];                            
40005548:   e2 24 20 08     st  %l1, [ %l0 + 8 ]                                          
    for (device = 0; device < c->device_count; device++)                                  
4000554c:   ac 05 a0 01     inc  %l6                                                      
      fd->devices[device].segment_count = segment_count;                                  
40005550:   e6 24 20 04     st  %l3, [ %l0 + 4 ]                                          
    for (device = 0; device < c->device_count; device++)                                  
40005554:   a2 04 60 0c     add  %l1, 0xc, %l1                                            
40005558:   80 a5 80 1b     cmp  %l6, %i3                                                 
4000555c:   12 bf ff d1     bne  400054a0 <rtems_fdisk_initialize+0x260>                  <== NEVER TAKEN
40005560:   a0 04 20 0c     add  %l0, 0xc, %l0                                            
    }                                                                                     
                                                                                          
    fd->device_count = c->device_count;                                                   
40005564:   f6 27 20 30     st  %i3, [ %i4 + 0x30 ]                                       
                                                                                          
    ret = rtems_fdisk_recover_block_mappings (fd);                                        
40005568:   7f ff f9 0d     call  4000399c <rtems_fdisk_recover_block_mappings>           
4000556c:   90 10 00 1c     mov  %i4, %o0                                                 
    if (ret)                                                                              
40005570:   ba 92 20 00     orcc  %o0, 0, %i5                                             
40005574:   12 80 00 2d     bne  40005628 <rtems_fdisk_initialize+0x3e8>                  <== NEVER TAKEN
40005578:   01 00 00 00     nop                                                           
      rtems_fdisk_error ("recovery of disk failed: %s (%d)",                              
                         strerror (ret), ret);                                            
      return ret;                                                                         
    }                                                                                     
                                                                                          
    ret = rtems_fdisk_compact (fd);                                                       
4000557c:   7f ff f8 58     call  400036dc <rtems_fdisk_compact>                          
40005580:   90 10 00 1c     mov  %i4, %o0                                                 
    if (ret)                                                                              
40005584:   ba 92 20 00     orcc  %o0, 0, %i5                                             
40005588:   12 80 00 39     bne  4000566c <rtems_fdisk_initialize+0x42c>                  <== NEVER TAKEN
4000558c:   c2 05 61 94     ld  [ %l5 + 0x194 ], %g1                                      
  for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++, fd++)         
40005590:   b2 06 60 01     inc  %i1                                                      
40005594:   b4 06 a0 20     add  %i2, 0x20, %i2                                           
40005598:   80 a0 40 19     cmp  %g1, %i1                                                 
4000559c:   18 bf ff 58     bgu  400052fc <rtems_fdisk_initialize+0xbc>                   <== NEVER TAKEN
400055a0:   b8 07 20 84     add  %i4, 0x84, %i4                                           
      return ret;                                                                         
    }                                                                                     
  }                                                                                       
                                                                                          
  return RTEMS_SUCCESSFUL;                                                                
}                                                                                         
400055a4:   81 c7 e0 08     ret                                                           
400055a8:   91 e8 00 17     restore  %g0, %l7, %o0                                        
      fd->devices[device].segments = calloc (segment_count,                               
400055ac:   92 10 20 30     mov  0x30, %o1                                                <== NOT EXECUTED
400055b0:   40 00 00 75     call  40005784 <calloc>                                       <== NOT EXECUTED
400055b4:   90 10 20 00     clr  %o0                                                      <== NOT EXECUTED
      if (!fd->devices[device].segments)                                                  
400055b8:   80 a2 20 00     cmp  %o0, 0                                                   <== NOT EXECUTED
400055bc:   12 bf ff e3     bne  40005548 <rtems_fdisk_initialize+0x308>                  <== NOT EXECUTED
400055c0:   d0 24 00 00     st  %o0, [ %l0 ]                                              <== NOT EXECUTED
        unlink (name);                                                                    
400055c4:   40 00 09 6c     call  40007b74 <unlink>                                       <== NOT EXECUTED
400055c8:   90 07 bf f0     add  %fp, -16, %o0                                            <== NOT EXECUTED
        free (fd->copy_buffer);                                                           
400055cc:   40 00 01 10     call  40005a0c <free>                                         <== NOT EXECUTED
400055d0:   d0 07 20 78     ld  [ %i4 + 0x78 ], %o0                                       <== NOT EXECUTED
        free (fd->blocks);                                                                
400055d4:   40 00 01 0e     call  40005a0c <free>                                         <== NOT EXECUTED
400055d8:   d0 07 20 18     ld  [ %i4 + 0x18 ], %o0                                       <== NOT EXECUTED
        free (fd->devices);                                                               
400055dc:   d0 07 20 2c     ld  [ %i4 + 0x2c ], %o0                                       <== NOT EXECUTED
400055e0:   40 00 01 0b     call  40005a0c <free>                                         <== NOT EXECUTED
400055e4:   ba 10 20 1a     mov  0x1a, %i5                                                <== NOT EXECUTED
      return RTEMS_NO_MEMORY;                                                             
400055e8:   ae 10 00 1d     mov  %i5, %l7                                                 <== NOT EXECUTED
}                                                                                         
400055ec:   81 c7 e0 08     ret                                                           <== NOT EXECUTED
400055f0:   91 e8 00 17     restore  %g0, %l7, %o0                                        <== NOT EXECUTED
    uint32_t blocks = 0;                                                                  
400055f4:   10 bf ff 83     b  40005400 <rtems_fdisk_initialize+0x1c0>                    <== NOT EXECUTED
400055f8:   ac 10 20 00     clr  %l6                                                      <== NOT EXECUTED
      free (fd->copy_buffer);                                                             
400055fc:   40 00 01 04     call  40005a0c <free>                                         <== NOT EXECUTED
40005600:   d0 07 20 78     ld  [ %i4 + 0x78 ], %o0                                       <== NOT EXECUTED
      free (fd->blocks);                                                                  
40005604:   40 00 01 02     call  40005a0c <free>                                         <== NOT EXECUTED
40005608:   d0 07 20 18     ld  [ %i4 + 0x18 ], %o0                                       <== NOT EXECUTED
      free (fd->devices);                                                                 
4000560c:   40 00 01 00     call  40005a0c <free>                                         <== NOT EXECUTED
40005610:   d0 07 20 2c     ld  [ %i4 + 0x2c ], %o0                                       <== NOT EXECUTED
      rtems_fdisk_error ("disk create phy failed");                                       
40005614:   11 10 00 b4     sethi  %hi(0x4002d000), %o0                                   <== NOT EXECUTED
      return RTEMS_NO_MEMORY;                                                             
40005618:   ae 10 00 1d     mov  %i5, %l7                                                 <== NOT EXECUTED
      rtems_fdisk_error ("disk create phy failed");                                       
4000561c:   7f ff f5 0f     call  40002a58 <rtems_fdisk_error>                            <== NOT EXECUTED
40005620:   90 12 22 00     or  %o0, 0x200, %o0                                           <== NOT EXECUTED
      return sc;                                                                          
40005624:   30 bf ff f2     b,a   400055ec <rtems_fdisk_initialize+0x3ac>                 <== NOT EXECUTED
      unlink (name);                                                                      
40005628:   40 00 09 53     call  40007b74 <unlink>                                       <== NOT EXECUTED
4000562c:   90 07 bf f0     add  %fp, -16, %o0                                            <== NOT EXECUTED
      free (fd->copy_buffer);                                                             
40005630:   40 00 00 f7     call  40005a0c <free>                                         <== NOT EXECUTED
40005634:   d0 07 20 78     ld  [ %i4 + 0x78 ], %o0                                       <== NOT EXECUTED
      free (fd->blocks);                                                                  
40005638:   40 00 00 f5     call  40005a0c <free>                                         <== NOT EXECUTED
4000563c:   d0 07 20 18     ld  [ %i4 + 0x18 ], %o0                                       <== NOT EXECUTED
      free (fd->devices);                                                                 
40005640:   40 00 00 f3     call  40005a0c <free>                                         <== NOT EXECUTED
40005644:   d0 07 20 2c     ld  [ %i4 + 0x2c ], %o0                                       <== NOT EXECUTED
      rtems_fdisk_error ("recovery of disk failed: %s (%d)",                              
40005648:   40 00 74 e5     call  400229dc <strerror>                                     <== NOT EXECUTED
4000564c:   90 10 00 1d     mov  %i5, %o0                                                 <== NOT EXECUTED
40005650:   94 10 00 1d     mov  %i5, %o2                                                 <== NOT EXECUTED
40005654:   92 10 00 08     mov  %o0, %o1                                                 <== NOT EXECUTED
      return RTEMS_NO_MEMORY;                                                             
40005658:   ae 10 00 1d     mov  %i5, %l7                                                 <== NOT EXECUTED
      rtems_fdisk_error ("recovery of disk failed: %s (%d)",                              
4000565c:   11 10 00 b4     sethi  %hi(0x4002d000), %o0                                   <== NOT EXECUTED
40005660:   7f ff f4 fe     call  40002a58 <rtems_fdisk_error>                            <== NOT EXECUTED
40005664:   90 12 22 18     or  %o0, 0x218, %o0 ! 4002d218 <__func__.6+0xb70>             <== NOT EXECUTED
      return ret;                                                                         
40005668:   30 bf ff e1     b,a   400055ec <rtems_fdisk_initialize+0x3ac>                 <== NOT EXECUTED
      unlink (name);                                                                      
4000566c:   40 00 09 42     call  40007b74 <unlink>                                       <== NOT EXECUTED
40005670:   90 07 bf f0     add  %fp, -16, %o0                                            <== NOT EXECUTED
      free (fd->copy_buffer);                                                             
40005674:   40 00 00 e6     call  40005a0c <free>                                         <== NOT EXECUTED
40005678:   d0 07 20 78     ld  [ %i4 + 0x78 ], %o0                                       <== NOT EXECUTED
      free (fd->blocks);                                                                  
4000567c:   40 00 00 e4     call  40005a0c <free>                                         <== NOT EXECUTED
40005680:   d0 07 20 18     ld  [ %i4 + 0x18 ], %o0                                       <== NOT EXECUTED
      free (fd->devices);                                                                 
40005684:   40 00 00 e2     call  40005a0c <free>                                         <== NOT EXECUTED
40005688:   d0 07 20 2c     ld  [ %i4 + 0x2c ], %o0                                       <== NOT EXECUTED
      rtems_fdisk_error ("compacting of disk failed: %s (%d)",                            
4000568c:   40 00 74 d4     call  400229dc <strerror>                                     <== NOT EXECUTED
40005690:   90 10 00 1d     mov  %i5, %o0                                                 <== NOT EXECUTED
40005694:   94 10 00 1d     mov  %i5, %o2                                                 <== NOT EXECUTED
40005698:   92 10 00 08     mov  %o0, %o1                                                 <== NOT EXECUTED
      return RTEMS_NO_MEMORY;                                                             
4000569c:   ae 10 00 1d     mov  %i5, %l7                                                 <== NOT EXECUTED
      rtems_fdisk_error ("compacting of disk failed: %s (%d)",                            
400056a0:   11 10 00 b4     sethi  %hi(0x4002d000), %o0                                   <== NOT EXECUTED
400056a4:   7f ff f4 ed     call  40002a58 <rtems_fdisk_error>                            <== NOT EXECUTED
400056a8:   90 12 22 40     or  %o0, 0x240, %o0 ! 4002d240 <__func__.6+0xb98>             <== NOT EXECUTED
      return ret;                                                                         
400056ac:   30 bf ff d0     b,a   400055ec <rtems_fdisk_initialize+0x3ac>                 <== NOT EXECUTED
    return RTEMS_NO_MEMORY;                                                               
400056b0:   10 bf ff bd     b  400055a4 <rtems_fdisk_initialize+0x364>                    <== NOT EXECUTED
400056b4:   ae 10 20 1a     mov  0x1a, %l7                                                <== NOT EXECUTED
      return RTEMS_NO_MEMORY;                                                             
400056b8:   ba 10 20 1a     mov  0x1a, %i5                                                <== NOT EXECUTED
400056bc:   10 bf ff cc     b  400055ec <rtems_fdisk_initialize+0x3ac>                    <== NOT EXECUTED
400056c0:   ae 10 00 1d     mov  %i5, %l7                                                 <== NOT EXECUTED
                                                                                          
===============================================================================
40003474 <rtems_ide_part_table_initialize>:                                               
 *      RTEMS_NO_MEMOTY if cannot have not enough memory,                                 
 *      RTEMS_INTERNAL_ERROR if other error occurs.                                       
 */                                                                                       
rtems_status_code                                                                         
rtems_ide_part_table_initialize(const char *dev_name)                                     
{                                                                                         
40003474:   9d e3 bf 90     save  %sp, -112, %sp                                          
    rtems_part_desc_t          *part_desc;                                                
                                                                                          
    /* logical device name /dev/hdxyy */                                                  
    char                        name[RTEMS_IDE_PARTITION_DEV_NAME_LENGTH_MAX];            
                                                                                          
    disk_desc = (rtems_disk_desc_t *) calloc(1, sizeof(rtems_disk_desc_t));               
40003478:   92 10 21 1c     mov  0x11c, %o1                                               
4000347c:   40 00 01 1c     call  400038ec <calloc>                                       
40003480:   90 10 20 01     mov  1, %o0                                                   
    if (disk_desc == NULL)                                                                
40003484:   b6 92 20 00     orcc  %o0, 0, %i3                                             
40003488:   02 80 00 4f     be  400035c4 <rtems_ide_part_table_initialize+0x150>          <== NEVER TAKEN
4000348c:   92 10 00 1b     mov  %i3, %o1                                                 
    {                                                                                     
        return RTEMS_NO_MEMORY;                                                           
    }                                                                                     
                                                                                          
    /* get partition table */                                                             
    rc = partition_table_get(dev_name, disk_desc);                                        
40003490:   7f ff fe c4     call  40002fa0 <partition_table_get>                          
40003494:   90 10 00 18     mov  %i0, %o0                                                 
    if (rc != RTEMS_SUCCESSFUL)                                                           
40003498:   b2 92 20 00     orcc  %o0, 0, %i1                                             
4000349c:   12 80 00 46     bne  400035b4 <rtems_ide_part_table_initialize+0x140>         <== NEVER TAKEN
400034a0:   01 00 00 00     nop                                                           
        free(disk_desc);                                                                  
        return rc;                                                                        
    }                                                                                     
                                                                                          
    /* create logical disks on the physical one */                                        
    for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)                     
400034a4:   c2 06 e0 1c     ld  [ %i3 + 0x1c ], %g1                                       
400034a8:   80 a0 60 00     cmp  %g1, 0                                                   
400034ac:   04 80 00 29     ble  40003550 <rtems_ide_part_table_initialize+0xdc>          <== NEVER TAKEN
400034b0:   35 10 00 7e     sethi  %hi(0x4001f800), %i2                                   
                                                                                          
        rc = rtems_blkdev_create_partition(name, dev_name, part_desc->start,              
                                           part_desc->size);                              
        if (rc != RTEMS_SUCCESSFUL)                                                       
        {                                                                                 
            fprintf(stdout,"Cannot create device %s, error code %d\n", name, rc);         
400034b4:   23 10 00 7e     sethi  %hi(0x4001f800), %l1                                   
    for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)                     
400034b8:   ba 10 20 00     clr  %i5                                                      
400034bc:   a0 06 e0 1c     add  %i3, 0x1c, %l0                                           
        sprintf(name, "%s%d", dev_name, part_num + 1);                                    
400034c0:   b4 16 a0 40     or  %i2, 0x40, %i2                                            
            fprintf(stdout,"Cannot create device %s, error code %d\n", name, rc);         
400034c4:   10 80 00 06     b  400034dc <rtems_ide_part_table_initialize+0x68>            
400034c8:   a2 14 60 48     or  %l1, 0x48, %l1                                            
    for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)                     
400034cc:   c2 06 e0 1c     ld  [ %i3 + 0x1c ], %g1                                       
400034d0:   80 a7 40 01     cmp  %i5, %g1                                                 
400034d4:   36 80 00 20     bge,a   40003554 <rtems_ide_part_table_initialize+0xe0>       
400034d8:   b4 06 e0 20     add  %i3, 0x20, %i2                                           
        sprintf(name, "%s%d", dev_name, part_num + 1);                                    
400034dc:   ba 07 60 01     inc  %i5                                                      
400034e0:   92 10 00 1a     mov  %i2, %o1                                                 
400034e4:   94 10 00 18     mov  %i0, %o2                                                 
400034e8:   96 10 00 1d     mov  %i5, %o3                                                 
400034ec:   40 00 49 3f     call  400159e8 <sprintf>                                      
400034f0:   90 07 bf f0     add  %fp, -16, %o0                                            
        part_desc = disk_desc->partitions[part_num];                                      
400034f4:   83 2f 60 02     sll  %i5, 2, %g1                                              
400034f8:   c2 04 00 01     ld  [ %l0 + %g1 ], %g1                                        
        rc = rtems_blkdev_create_partition(name, dev_name, part_desc->start,              
400034fc:   92 10 00 18     mov  %i0, %o1                                                 
        if (part_desc == NULL)                                                            
40003500:   80 a0 60 00     cmp  %g1, 0                                                   
40003504:   02 bf ff f2     be  400034cc <rtems_ide_part_table_initialize+0x58>           
40003508:   90 07 bf f0     add  %fp, -16, %o0                                            
        rc = rtems_blkdev_create_partition(name, dev_name, part_desc->start,              
4000350c:   d6 00 60 08     ld  [ %g1 + 8 ], %o3                                          
40003510:   7f ff fd 95     call  40002b64 <rtems_blkdev_create_partition>                
40003514:   d4 00 60 04     ld  [ %g1 + 4 ], %o2                                          
        if (rc != RTEMS_SUCCESSFUL)                                                       
40003518:   b8 92 20 00     orcc  %o0, 0, %i4                                             
4000351c:   22 bf ff ed     be,a   400034d0 <rtems_ide_part_table_initialize+0x5c>        <== ALWAYS TAKEN
40003520:   c2 06 e0 1c     ld  [ %i3 + 0x1c ], %g1                                       
            fprintf(stdout,"Cannot create device %s, error code %d\n", name, rc);         
40003524:   7f ff f8 51     call  40001668 <__getreent>                                   <== NOT EXECUTED
40003528:   01 00 00 00     nop                                                           <== NOT EXECUTED
4000352c:   d0 02 20 08     ld  [ %o0 + 8 ], %o0                                          <== NOT EXECUTED
40003530:   96 10 00 1c     mov  %i4, %o3                                                 <== NOT EXECUTED
40003534:   94 07 bf f0     add  %fp, -16, %o2                                            <== NOT EXECUTED
40003538:   40 00 47 8e     call  40015370 <fprintf>                                      <== NOT EXECUTED
4000353c:   92 10 00 11     mov  %l1, %o1                                                 <== NOT EXECUTED
    for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)                     
40003540:   c2 06 e0 1c     ld  [ %i3 + 0x1c ], %g1                                       <== NOT EXECUTED
40003544:   80 a7 40 01     cmp  %i5, %g1                                                 <== NOT EXECUTED
40003548:   26 bf ff e6     bl,a   400034e0 <rtems_ide_part_table_initialize+0x6c>        <== NOT EXECUTED
4000354c:   ba 07 60 01     inc  %i5                                                      <== NOT EXECUTED
40003550:   b4 06 e0 20     add  %i3, 0x20, %i2                                           <== NOT EXECUTED
40003554:   a0 06 e0 30     add  %i3, 0x30, %l0                                           
        partition_free(disk_desc->partitions[part_num]);                                  
40003558:   f8 06 80 00     ld  [ %i2 ], %i4                                              
    if (part_desc == NULL)                                                                
4000355c:   80 a7 20 00     cmp  %i4, 0                                                   
40003560:   22 80 00 12     be,a   400035a8 <rtems_ide_part_table_initialize+0x134>       
40003564:   b4 06 a0 04     add  %i2, 4, %i2                                              
    return ((type == EXTENDED_PARTITION) || (type == LINUX_EXTENDED));                    
40003568:   c2 0f 20 01     ldub  [ %i4 + 1 ], %g1                                        
    if (is_extended(part_desc->sys_type))                                                 
4000356c:   82 08 60 7f     and  %g1, 0x7f, %g1                                           
40003570:   80 a0 60 05     cmp  %g1, 5                                                   
40003574:   12 80 00 0a     bne  4000359c <rtems_ide_part_table_initialize+0x128>         <== ALWAYS TAKEN
40003578:   01 00 00 00     nop                                                           
4000357c:   ba 07 20 18     add  %i4, 0x18, %i5                                           <== NOT EXECUTED
40003580:   b0 07 20 28     add  %i4, 0x28, %i0                                           <== NOT EXECUTED
            partition_free(part_desc->sub_part[part_num]);                                
40003584:   7f ff ff 07     call  400031a0 <partition_free>                               <== NOT EXECUTED
40003588:   d0 07 40 00     ld  [ %i5 ], %o0                                              <== NOT EXECUTED
        for (part_num = 0;                                                                
4000358c:   ba 07 60 04     add  %i5, 4, %i5                                              <== NOT EXECUTED
40003590:   80 a7 40 18     cmp  %i5, %i0                                                 <== NOT EXECUTED
40003594:   12 bf ff fc     bne  40003584 <rtems_ide_part_table_initialize+0x110>         <== NOT EXECUTED
40003598:   01 00 00 00     nop                                                           <== NOT EXECUTED
    free(part_desc);                                                                      
4000359c:   40 00 01 42     call  40003aa4 <free>                                         
400035a0:   90 10 00 1c     mov  %i4, %o0                                                 
    for (part_num = 0;                                                                    
400035a4:   b4 06 a0 04     add  %i2, 4, %i2                                              
400035a8:   80 a6 80 10     cmp  %i2, %l0                                                 
400035ac:   32 bf ff ec     bne,a   4000355c <rtems_ide_part_table_initialize+0xe8>       
400035b0:   f8 06 80 00     ld  [ %i2 ], %i4                                              
    free(disk_desc);                                                                      
400035b4:   40 00 01 3c     call  40003aa4 <free>                                         
400035b8:   90 10 00 1b     mov  %i3, %o0                                                 
    }                                                                                     
                                                                                          
    partition_table_free(disk_desc);                                                      
                                                                                          
    return RTEMS_SUCCESSFUL;                                                              
}                                                                                         
400035bc:   81 c7 e0 08     ret                                                           
400035c0:   91 e8 00 19     restore  %g0, %i1, %o0                                        
        return RTEMS_NO_MEMORY;                                                           
400035c4:   10 bf ff fe     b  400035bc <rtems_ide_part_table_initialize+0x148>           <== NOT EXECUTED
400035c8:   b2 10 20 1a     mov  0x1a, %i1                                                <== NOT EXECUTED
                                                                                          
===============================================================================
400022e0 <rtems_sparse_disk_create_and_register>:                                         
{                                                                                         
400022e0:   9d e3 bf 98     save  %sp, -104, %sp                                          
                                + key_table_size + data_size;                             
400022e4:   90 06 60 08     add  %i1, 8, %o0                                              
400022e8:   90 5a 00 1a     smul  %o0, %i2, %o0                                           
  rtems_sparse_disk *const sd = (rtems_sparse_disk *) malloc(                             
400022ec:   40 00 01 71     call  400028b0 <malloc>                                       
400022f0:   90 02 20 2c     add  %o0, 0x2c, %o0                                           
  if ( sparse_disk != NULL ) {                                                            
400022f4:   92 92 20 00     orcc  %o0, 0, %o1                                             
400022f8:   02 80 00 0c     be  40002328 <rtems_sparse_disk_create_and_register+0x48>     <== NEVER TAKEN
400022fc:   03 10 00 07     sethi  %hi(0x40001c00), %g1                                   
    sc = rtems_sparse_disk_register(                                                      
40002300:   82 10 63 78     or  %g1, 0x378, %g1 ! 40001f78 <rtems_sparse_disk_free>       
40002304:   c2 23 a0 5c     st  %g1, [ %sp + 0x5c ]                                       
40002308:   9a 10 00 1c     mov  %i4, %o5                                                 
4000230c:   98 10 00 1b     mov  %i3, %o4                                                 
40002310:   96 10 00 1a     mov  %i2, %o3                                                 
40002314:   94 10 00 19     mov  %i1, %o2                                                 
40002318:   7f ff ff be     call  40002210 <rtems_sparse_disk_register>                   
4000231c:   90 10 00 18     mov  %i0, %o0                                                 
40002320:   81 c7 e0 08     ret                                                           
40002324:   91 e8 00 08     restore  %g0, %o0, %o0                                        
}                                                                                         
40002328:   81 c7 e0 08     ret                                                           <== NOT EXECUTED
4000232c:   91 e8 20 1a     restore  %g0, 0x1a, %o0                                       <== NOT EXECUTED
                                                                                          
===============================================================================
40002210 <rtems_sparse_disk_register>:                                                    
  uint32_t                         media_block_size,                                      
  rtems_blkdev_bnum                blocks_with_buffer,                                    
  rtems_blkdev_bnum                media_block_count,                                     
  uint8_t                          fill_pattern,                                          
  rtems_sparse_disk_delete_handler sparse_disk_delete )                                   
{                                                                                         
40002210:   9d e3 bf a0     save  %sp, -96, %sp                                           
        sparse_disk_ioctl,                                                                
        sparse_disk                                                                       
      );                                                                                  
    }                                                                                     
  } else {                                                                                
    sc = RTEMS_INVALID_NUMBER;                                                            
40002214:   82 10 20 0a     mov  0xa, %g1                                                 
{                                                                                         
40002218:   e4 07 a0 5c     ld  [ %fp + 0x5c ], %l2                                       
4000221c:   a2 10 00 1c     mov  %i4, %l1                                                 
  if ( blocks_with_buffer <= media_block_count ) {                                        
40002220:   80 a6 c0 1c     cmp  %i3, %i4                                                 
40002224:   08 80 00 04     bleu  40002234 <rtems_sparse_disk_register+0x24>              <== ALWAYS TAKEN
40002228:   a0 10 00 1a     mov  %i2, %l0                                                 
  }                                                                                       
                                                                                          
  return sc;                                                                              
}                                                                                         
4000222c:   81 c7 e0 08     ret                                                           <== NOT EXECUTED
40002230:   91 e8 00 01     restore  %g0, %g1, %o0                                        <== NOT EXECUTED
  if ( NULL == sd )                                                                       
40002234:   80 a6 60 00     cmp  %i1, 0                                                   
40002238:   02 80 00 28     be  400022d8 <rtems_sparse_disk_register+0xc8>                <== NEVER TAKEN
4000223c:   92 10 20 00     clr  %o1                                                      
  size_t const key_table_size = blocks_with_buffer                                        
40002240:   b9 2e e0 03     sll  %i3, 3, %i4                                              
  memset( data, 0, sizeof( rtems_sparse_disk ) + key_table_size );                        
40002244:   90 10 00 19     mov  %i1, %o0                                                 
40002248:   b4 07 20 2c     add  %i4, 0x2c, %i2                                           
4000224c:   40 00 68 45     call  4001c360 <memset>                                       
40002250:   94 10 00 1a     mov  %i2, %o2                                                 
  sd->fill_pattern = fill_pattern;                                                        
40002254:   fa 2e 60 24     stb  %i5, [ %i1 + 0x24 ]                                      
  memset( (uint8_t *) ( data + sizeof( rtems_sparse_disk ) + key_table_size ),            
40002258:   b4 06 40 1a     add  %i1, %i2, %i2                                            
4000225c:   94 5e c0 10     smul  %i3, %l0, %o2                                           
40002260:   92 10 00 1d     mov  %i5, %o1                                                 
40002264:   40 00 68 3f     call  4001c360 <memset>                                       
40002268:   90 10 00 1a     mov  %i2, %o0                                                 
  data                  += sizeof( rtems_sparse_disk );                                   
4000226c:   86 06 60 2c     add  %i1, 0x2c, %g3                                           
static __inline void                                                                      
_Mutex_Initialize_named(struct _Mutex_Control *_mutex, const char *_name)                 
{                                                                                         
    struct _Mutex_Control _init = _MUTEX_NAMED_INITIALIZER(_name);                        
                                                                                          
    *_mutex = _init;                                                                      
40002270:   03 10 00 99     sethi  %hi(0x40026400), %g1                                   
  sd->delete_handler = sparse_disk_delete;                                                
40002274:   e4 26 60 20     st  %l2, [ %i1 + 0x20 ]                                       
40002278:   82 10 63 c8     or  %g1, 0x3c8, %g1                                           
4000227c:   c0 26 40 00     clr  [ %i1 ]                                                  
  for ( i = 0; i < blocks_with_buffer; ++i, data += media_block_size ) {                  
40002280:   80 a6 e0 00     cmp  %i3, 0                                                   
40002284:   c0 26 60 04     clr  [ %i1 + 4 ]                                              
40002288:   c0 26 60 08     clr  [ %i1 + 8 ]                                              
4000228c:   c0 26 60 0c     clr  [ %i1 + 0xc ]                                            
40002290:   c2 26 60 10     st  %g1, [ %i1 + 0x10 ]                                       
  sd->blocks_with_buffer = blocks_with_buffer;                                            
40002294:   f6 26 60 14     st  %i3, [ %i1 + 0x14 ]                                       
  for ( i = 0; i < blocks_with_buffer; ++i, data += media_block_size ) {                  
40002298:   02 80 00 09     be  400022bc <rtems_sparse_disk_register+0xac>                <== NEVER TAKEN
4000229c:   c6 26 60 28     st  %g3, [ %i1 + 0x28 ]                                       
400022a0:   82 10 00 19     mov  %i1, %g1                                                 
400022a4:   86 07 00 19     add  %i4, %i1, %g3                                            
    sd->key_table[i].data = data;                                                         
400022a8:   f4 20 60 30     st  %i2, [ %g1 + 0x30 ]                                       
  for ( i = 0; i < blocks_with_buffer; ++i, data += media_block_size ) {                  
400022ac:   82 00 60 08     add  %g1, 8, %g1                                              
400022b0:   80 a0 c0 01     cmp  %g3, %g1                                                 
400022b4:   12 bf ff fd     bne  400022a8 <rtems_sparse_disk_register+0x98>               
400022b8:   b4 06 80 10     add  %i2, %l0, %i2                                            
  sd->media_block_size = media_block_size;                                                
400022bc:   e0 26 60 1c     st  %l0, [ %i1 + 0x1c ]                                       
      sc = rtems_blkdev_create(                                                           
400022c0:   b8 10 00 19     mov  %i1, %i4                                                 
400022c4:   37 10 00 07     sethi  %hi(0x40001c00), %i3                                   
400022c8:   b4 10 00 11     mov  %l1, %i2                                                 
400022cc:   b6 16 e3 84     or  %i3, 0x384, %i3                                           
400022d0:   40 00 29 c7     call  4000c9ec <rtems_blkdev_create>                          
400022d4:   93 e8 00 10     restore  %g0, %l0, %o1                                        
  return sc;                                                                              
400022d8:   10 bf ff d5     b  4000222c <rtems_sparse_disk_register+0x1c>                 <== NOT EXECUTED
400022dc:   82 10 20 09     mov  9, %g1                                                   <== NOT EXECUTED