===============================================================================
4003963c <ramdisk_free>:
                                             

                                                                     
  return rd;
                                                         
}
                                                                    

                                                                     
void ramdisk_free(ramdisk *rd)
                                       
{
                                                                    
4003963c:	9d e3 bf a0 	save  %sp, -96, %sp
                           <== NOT EXECUTED
  if (rd != NULL) {
                                                  
40039640:	80 a6 20 00 	cmp  %i0, 0
                                   <== NOT EXECUTED
40039644:	02 80 00 0c 	be  40039674 <ramdisk_free+0x38>
              <== NOT EXECUTED
40039648:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
    if (rd->malloced) {
                                              
4003964c:	c2 0e 20 0d 	ldub  [ %i0 + 0xd ], %g1
                      <== NOT EXECUTED
40039650:	80 a0 60 00 	cmp  %g1, 0
                                   <== NOT EXECUTED
40039654:	12 80 00 04 	bne  40039664 <ramdisk_free+0x28>
             <== NOT EXECUTED
40039658:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
      free(rd->area);
                                                
    }
                                                                
    free(rd);
                                                        
4003965c:	7f ff 48 09 	call  4000b680 <free>
                         <== NOT EXECUTED
40039660:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
      free(rd->area);
                                                
40039664:	7f ff 48 07 	call  4000b680 <free>
                         <== NOT EXECUTED
40039668:	d0 06 20 08 	ld  [ %i0 + 8 ], %o0
                          <== NOT EXECUTED
    free(rd);
                                                        
4003966c:	7f ff 48 05 	call  4000b680 <free>
                         <== NOT EXECUTED
40039670:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
  }
                                                                  
}
                                                                    
40039674:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40039678:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED

                                                                     
===============================================================================
40039390 <ramdisk_initialize>:
                                       
rtems_device_driver
                                                  
ramdisk_initialize(
                                                  
    rtems_device_major_number major,
                                 
    rtems_device_minor_number minor RTEMS_UNUSED,
                    
    void *arg RTEMS_UNUSED)
                                          
{
                                                                    
40039390:	9d e3 bf 80 	save  %sp, -128, %sp
                          <== NOT EXECUTED
    rtems_device_minor_number i;
                                     
    rtems_ramdisk_config *c = rtems_ramdisk_configuration;
           
    struct ramdisk *r;
                                               
    rtems_status_code rc;
                                            

                                                                     
    rc = rtems_disk_io_initialize();
                                 
40039394:	7f ff 3d 50 	call  400088d4 <rtems_disk_io_initialize>
     <== NOT EXECUTED
40039398:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
    if (rc != RTEMS_SUCCESSFUL)
                                      
4003939c:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
400393a0:	02 80 00 04 	be  400393b0 <ramdisk_initialize+0x20>
        <== NOT EXECUTED
400393a4:	33 10 02 2e 	sethi  %hi(0x4008b800), %i1
                   <== NOT EXECUTED
            }
                                                        
            r->initialized = false;
                                  
        }
                                                            
    }
                                                                
    return RTEMS_SUCCESSFUL;
                                         
}
                                                                    
400393a8:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
400393ac:	91 e8 00 08 	restore  %g0, %o0, %o0
                        <== NOT EXECUTED
    r = calloc(rtems_ramdisk_configuration_size, sizeof(struct ramdisk));

400393b0:	f8 06 61 0c 	ld  [ %i1 + 0x10c ], %i4
                      <== NOT EXECUTED
400393b4:	92 10 20 10 	mov  0x10, %o1
                                <== NOT EXECUTED
400393b8:	7f ff 44 12 	call  4000a400 <calloc>
                       <== NOT EXECUTED
400393bc:	90 10 00 1c 	mov  %i4, %o0
                                 <== NOT EXECUTED
    r->trace = false;
                                                
400393c0:	c0 2a 20 0e 	clrb  [ %o0 + 0xe ]
                           <== NOT EXECUTED
    for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
 
400393c4:	80 a7 20 00 	cmp  %i4, 0
                                   <== NOT EXECUTED
400393c8:	02 80 00 32 	be  40039490 <ramdisk_initialize+0x100>
       <== NOT EXECUTED
400393cc:	ba 10 00 08 	mov  %o0, %i5
                                 <== NOT EXECUTED
    rtems_ramdisk_config *c = rtems_ramdisk_configuration;
           
400393d0:	39 10 02 2e 	sethi  %hi(0x4008b800), %i4
                   <== NOT EXECUTED
        char name [] = RAMDISK_DEVICE_BASE_NAME "a";
                 
400393d4:	21 0b d9 19 	sethi  %hi(0x2f646400), %l0
                   <== NOT EXECUTED
400393d8:	23 0b dc 99 	sethi  %hi(0x2f726400), %l1
                   <== NOT EXECUTED
        rc = rtems_disk_create_phys(dev, c->block_size, c->block_num,

400393dc:	25 10 00 e5 	sethi  %hi(0x40039400), %l2
                   <== NOT EXECUTED
    for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
 
400393e0:	b4 10 20 61 	mov  0x61, %i2
                                <== NOT EXECUTED
    rtems_ramdisk_config *c = rtems_ramdisk_configuration;
           
400393e4:	b8 17 21 10 	or  %i4, 0x110, %i4
                           <== NOT EXECUTED
    for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
 
400393e8:	b6 10 20 00 	clr  %i3
                                      <== NOT EXECUTED
400393ec:	b2 16 61 0c 	or  %i1, 0x10c, %i1
                           <== NOT EXECUTED
        char name [] = RAMDISK_DEVICE_BASE_NAME "a";
                 
400393f0:	a0 14 21 76 	or  %l0, 0x176, %l0
                           <== NOT EXECUTED
400393f4:	a2 14 60 61 	or  %l1, 0x61, %l1
                            <== NOT EXECUTED
        rc = rtems_disk_create_phys(dev, c->block_size, c->block_num,

400393f8:	a8 07 bf f0 	add  %fp, -16, %l4
                            <== NOT EXECUTED
400393fc:	a4 14 a0 d8 	or  %l2, 0xd8, %l2
                            <== NOT EXECUTED
            r->initialized = true;
                                   
40039400:	a6 10 20 01 	mov  1, %l3
                                   <== NOT EXECUTED
        r->block_size = c->block_size;
                               
40039404:	d4 07 00 00 	ld  [ %i4 ], %o2
                              <== NOT EXECUTED
        r->block_num = c->block_num;
                                 
40039408:	d6 07 20 04 	ld  [ %i4 + 4 ], %o3
                          <== NOT EXECUTED
        char name [] = RAMDISK_DEVICE_BASE_NAME "a";
                 
4003940c:	e0 3f bf f0 	std  %l0, [ %fp + -16 ]
                       <== NOT EXECUTED
        name [sizeof(RAMDISK_DEVICE_BASE_NAME) - 1] += i;
            
40039410:	f4 2f bf f7 	stb  %i2, [ %fp + -9 ]
                        <== NOT EXECUTED
        r->block_size = c->block_size;
                               
40039414:	d4 27 40 00 	st  %o2, [ %i5 ]
                              <== NOT EXECUTED
        r->block_num = c->block_num;
                                 
40039418:	d6 27 60 04 	st  %o3, [ %i5 + 4 ]
                          <== NOT EXECUTED
        char name [] = RAMDISK_DEVICE_BASE_NAME "a";
                 
4003941c:	c0 2f bf f8 	clrb  [ %fp + -8 ]
                            <== NOT EXECUTED
        if (c->location == NULL)
                                     
40039420:	c2 07 20 08 	ld  [ %i4 + 8 ], %g1
                          <== NOT EXECUTED
40039424:	80 a0 60 00 	cmp  %g1, 0
                                   <== NOT EXECUTED
40039428:	22 80 00 21 	be,a   400394ac <ramdisk_initialize+0x11c>
    <== NOT EXECUTED
4003942c:	e6 2f 60 0d 	stb  %l3, [ %i5 + 0xd ]
                       <== NOT EXECUTED
            r->malloced = false;
                                     
40039430:	c0 2f 60 0d 	clrb  [ %i5 + 0xd ]
                           <== NOT EXECUTED
            r->initialized = true;
                                   
40039434:	e6 2f 60 0c 	stb  %l3, [ %i5 + 0xc ]
                       <== NOT EXECUTED
            r->area = c->location;
                                   
40039438:	c2 27 60 08 	st  %g1, [ %i5 + 8 ]
                          <== NOT EXECUTED
        rc = rtems_disk_create_phys(dev, c->block_size, c->block_num,

4003943c:	9a 10 00 1d 	mov  %i5, %o5
                                 <== NOT EXECUTED
40039440:	e8 23 a0 5c 	st  %l4, [ %sp + 0x5c ]
                       <== NOT EXECUTED
40039444:	92 10 00 1b 	mov  %i3, %o1
                                 <== NOT EXECUTED
40039448:	98 10 00 12 	mov  %l2, %o4
                                 <== NOT EXECUTED
4003944c:	7f ff 3c a8 	call  400086ec <rtems_disk_create_phys>
       <== NOT EXECUTED
40039450:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
        if (rc != RTEMS_SUCCESSFUL)
                                  
40039454:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
40039458:	22 80 00 08 	be,a   40039478 <ramdisk_initialize+0xe8>
     <== NOT EXECUTED
4003945c:	b6 06 e0 01 	inc  %i3
                                      <== NOT EXECUTED
            if (r->malloced)
                                         
40039460:	c2 0f 60 0d 	ldub  [ %i5 + 0xd ], %g1
                      <== NOT EXECUTED
40039464:	80 a0 60 00 	cmp  %g1, 0
                                   <== NOT EXECUTED
40039468:	12 80 00 0d 	bne  4003949c <ramdisk_initialize+0x10c>
      <== NOT EXECUTED
4003946c:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
            r->initialized = false;
                                  
40039470:	c0 2f 60 0c 	clrb  [ %i5 + 0xc ]
                           <== NOT EXECUTED
    for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
 
40039474:	b6 06 e0 01 	inc  %i3
                                      <== NOT EXECUTED
40039478:	c2 06 40 00 	ld  [ %i1 ], %g1
                              <== NOT EXECUTED
4003947c:	b8 07 20 0c 	add  %i4, 0xc, %i4
                            <== NOT EXECUTED
40039480:	ba 07 60 10 	add  %i5, 0x10, %i5
                           <== NOT EXECUTED
40039484:	80 a0 40 1b 	cmp  %g1, %i3
                                 <== NOT EXECUTED
40039488:	18 bf ff df 	bgu  40039404 <ramdisk_initialize+0x74>
       <== NOT EXECUTED
4003948c:	b4 06 a0 01 	inc  %i2
                                      <== NOT EXECUTED
    return RTEMS_SUCCESSFUL;
                                         
40039490:	90 10 20 00 	clr  %o0
                                      <== NOT EXECUTED
}
                                                                    
40039494:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40039498:	91 e8 00 08 	restore  %g0, %o0, %o0
                        <== NOT EXECUTED
                free(r->area);
                                       
4003949c:	7f ff 48 79 	call  4000b680 <free>
                         <== NOT EXECUTED
400394a0:	d0 07 60 08 	ld  [ %i5 + 8 ], %o0
                          <== NOT EXECUTED
            r->initialized = false;
                                  
400394a4:	10 bf ff f4 	b  40039474 <ramdisk_initialize+0xe4>
         <== NOT EXECUTED
400394a8:	c0 2f 60 0c 	clrb  [ %i5 + 0xc ]
                           <== NOT EXECUTED
            r->area = malloc(r->block_size * r->block_num);
          
400394ac:	90 5a 80 0b 	smul  %o2, %o3, %o0
                           <== NOT EXECUTED
400394b0:	d6 27 bf e8 	st  %o3, [ %fp + -24 ]
                        <== NOT EXECUTED
400394b4:	7f ff 4a 36 	call  4000bd8c <malloc>
                       <== NOT EXECUTED
400394b8:	d4 27 bf ec 	st  %o2, [ %fp + -20 ]
                        <== NOT EXECUTED
400394bc:	d0 27 60 08 	st  %o0, [ %i5 + 8 ]
                          <== NOT EXECUTED
            if (r->area == NULL) /* No enough memory for this disk */

400394c0:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
400394c4:	d4 07 bf ec 	ld  [ %fp + -20 ], %o2
                        <== NOT EXECUTED
400394c8:	02 bf ff ea 	be  40039470 <ramdisk_initialize+0xe0>
        <== NOT EXECUTED
400394cc:	d6 07 bf e8 	ld  [ %fp + -24 ], %o3
                        <== NOT EXECUTED
400394d0:	10 bf ff db 	b  4003943c <ramdisk_initialize+0xac>
         <== NOT EXECUTED
400394d4:	e6 2f 60 0c 	stb  %l3, [ %i5 + 0xc ]
                       <== NOT EXECUTED

                                                                     
===============================================================================
400394d8 <ramdisk_ioctl>:
                                            
    return 0;
                                                        
}
                                                                    

                                                                     
int
                                                                  
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
       
{
                                                                    
400394d8:	9d e3 bf a0 	save  %sp, -96, %sp
                           <== NOT EXECUTED
    struct ramdisk *rd = rtems_disk_get_driver_data(dd);
             

                                                                     
    switch (req)
                                                     
400394dc:	03 08 00 10 	sethi  %hi(0x20004000), %g1
                   <== NOT EXECUTED
{
                                                                    
400394e0:	ba 10 00 1a 	mov  %i2, %i5
                                 <== NOT EXECUTED
    switch (req)
                                                     
400394e4:	82 10 62 07 	or  %g1, 0x207, %g1
                           <== NOT EXECUTED
400394e8:	80 a6 40 01 	cmp  %i1, %g1
                                 <== NOT EXECUTED
400394ec:	02 80 00 28 	be  4003958c <ramdisk_ioctl+0xb4>
             <== NOT EXECUTED
400394f0:	f6 06 20 3c 	ld  [ %i0 + 0x3c ], %i3
                       <== NOT EXECUTED
400394f4:	03 30 06 10 	sethi  %hi(0xc0184000), %g1
                   <== NOT EXECUTED
400394f8:	82 10 62 01 	or  %g1, 0x201, %g1	! c0184201 <RAM_END+0x7fd84201>
<== NOT EXECUTED
400394fc:	80 a6 40 01 	cmp  %i1, %g1
                                 <== NOT EXECUTED
40039500:	12 80 00 21 	bne  40039584 <ramdisk_ioctl+0xac>
            <== NOT EXECUTED
40039504:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
    {
                                                                
        case RTEMS_BLKIO_REQUEST:
                                    
        {
                                                            
            rtems_blkdev_request *r = argp;
                          

                                                                     
            switch (r->req)
                                          
40039508:	c2 06 80 00 	ld  [ %i2 ], %g1
                              <== NOT EXECUTED
4003950c:	80 a0 60 00 	cmp  %g1, 0
                                   <== NOT EXECUTED
40039510:	02 80 00 2f 	be  400395cc <ramdisk_ioctl+0xf4>
             <== NOT EXECUTED
40039514:	80 a0 60 01 	cmp  %g1, 1
                                   <== NOT EXECUTED
40039518:	12 80 00 27 	bne  400395b4 <ramdisk_ioctl+0xdc>
            <== NOT EXECUTED
4003951c:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
    for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
          
40039520:	c2 06 a0 10 	ld  [ %i2 + 0x10 ], %g1
                       <== NOT EXECUTED
40039524:	f2 06 e0 08 	ld  [ %i3 + 8 ], %i1
                          <== NOT EXECUTED
40039528:	80 a0 60 00 	cmp  %g1, 0
                                   <== NOT EXECUTED
4003952c:	02 80 00 0f 	be  40039568 <ramdisk_ioctl+0x90>
             <== NOT EXECUTED
40039530:	b8 06 a0 18 	add  %i2, 0x18, %i4
                           <== NOT EXECUTED
40039534:	b4 10 20 00 	clr  %i2
                                      <== NOT EXECUTED
        memcpy(to + (sg->block * rd->block_size), sg->buffer, sg->length);

40039538:	d0 07 00 00 	ld  [ %i4 ], %o0
                              <== NOT EXECUTED
4003953c:	c2 06 c0 00 	ld  [ %i3 ], %g1
                              <== NOT EXECUTED
40039540:	d4 07 20 04 	ld  [ %i4 + 4 ], %o2
                          <== NOT EXECUTED
40039544:	d2 07 20 08 	ld  [ %i4 + 8 ], %o1
                          <== NOT EXECUTED
40039548:	90 5a 00 01 	smul  %o0, %g1, %o0
                           <== NOT EXECUTED
4003954c:	40 00 9e a1 	call  40060fd0 <memcpy>
                       <== NOT EXECUTED
40039550:	90 06 40 08 	add  %i1, %o0, %o0
                            <== NOT EXECUTED
    for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
          
40039554:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1
                       <== NOT EXECUTED
40039558:	b4 06 a0 01 	inc  %i2
                                      <== NOT EXECUTED
4003955c:	80 a6 80 01 	cmp  %i2, %g1
                                 <== NOT EXECUTED
40039560:	0a bf ff f6 	bcs  40039538 <ramdisk_ioctl+0x60>
            <== NOT EXECUTED
40039564:	b8 07 20 10 	add  %i4, 0x10, %i4
                           <== NOT EXECUTED
40039568:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1
                          <== NOT EXECUTED
4003956c:	92 10 20 00 	clr  %o1
                                      <== NOT EXECUTED
40039570:	90 10 00 1d 	mov  %i5, %o0
                                 <== NOT EXECUTED
40039574:	9f c0 40 00 	call  %g1
                                     <== NOT EXECUTED
40039578:	b0 10 20 00 	clr  %i0
                                      <== NOT EXECUTED
            {
                                                        
                case RTEMS_BLKDEV_REQ_READ:
                          
                    return ramdisk_read(rd, r);
                      

                                                                     
                case RTEMS_BLKDEV_REQ_WRITE:
                         
                    return ramdisk_write(rd, r);
                     
4003957c:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40039580:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
              ramdisk_free(rd);
                                      
            }
                                                        
            break;
                                                   

                                                                     
        default:
                                                     
            return rtems_blkdev_ioctl (dd, req, argp);
               
40039584:	40 00 0e f4 	call  4003d154 <rtems_blkdev_ioctl>
           <== NOT EXECUTED
40039588:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
            if (rd->free_at_delete_request) {
                        
4003958c:	c2 0e e0 0f 	ldub  [ %i3 + 0xf ], %g1
                      <== NOT EXECUTED
40039590:	80 a0 60 00 	cmp  %g1, 0
                                   <== NOT EXECUTED
40039594:	12 80 00 22 	bne  4003961c <ramdisk_ioctl+0x144>
           <== NOT EXECUTED
40039598:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
            break;
                                                   
    }
                                                                

                                                                     
    errno = EINVAL;
                                                  
4003959c:	40 00 8c de 	call  4005c914 <__errno>
                      <== NOT EXECUTED
400395a0:	b0 10 3f ff 	mov  -1, %i0	! ffffffff <RAM_END+0xbfbfffff>
  <== NOT EXECUTED
400395a4:	82 10 20 16 	mov  0x16, %g1
                                <== NOT EXECUTED
400395a8:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
    return -1;
                                                       
}
                                                                    
400395ac:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
400395b0:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
                    errno = EINVAL;
                                  
400395b4:	40 00 8c d8 	call  4005c914 <__errno>
                      <== NOT EXECUTED
400395b8:	b0 10 3f ff 	mov  -1, %i0
                                  <== NOT EXECUTED
400395bc:	82 10 20 16 	mov  0x16, %g1
                                <== NOT EXECUTED
400395c0:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
                    return -1;
                                       
400395c4:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
400395c8:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
    for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
          
400395cc:	c2 06 a0 10 	ld  [ %i2 + 0x10 ], %g1
                       <== NOT EXECUTED
400395d0:	f2 06 e0 08 	ld  [ %i3 + 8 ], %i1
                          <== NOT EXECUTED
400395d4:	80 a0 60 00 	cmp  %g1, 0
                                   <== NOT EXECUTED
400395d8:	02 bf ff e4 	be  40039568 <ramdisk_ioctl+0x90>
             <== NOT EXECUTED
400395dc:	b8 06 a0 18 	add  %i2, 0x18, %i4
                           <== NOT EXECUTED
400395e0:	b4 10 20 00 	clr  %i2
                                      <== NOT EXECUTED
        memcpy(sg->buffer, from + (sg->block * rd->block_size), sg->length);

400395e4:	d2 07 00 00 	ld  [ %i4 ], %o1
                              <== NOT EXECUTED
400395e8:	c2 06 c0 00 	ld  [ %i3 ], %g1
                              <== NOT EXECUTED
400395ec:	d4 07 20 04 	ld  [ %i4 + 4 ], %o2
                          <== NOT EXECUTED
400395f0:	d0 07 20 08 	ld  [ %i4 + 8 ], %o0
                          <== NOT EXECUTED
400395f4:	92 5a 40 01 	smul  %o1, %g1, %o1
                           <== NOT EXECUTED
400395f8:	40 00 9e 76 	call  40060fd0 <memcpy>
                       <== NOT EXECUTED
400395fc:	92 06 40 09 	add  %i1, %o1, %o1
                            <== NOT EXECUTED
    for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
          
40039600:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1
                       <== NOT EXECUTED
40039604:	b4 06 a0 01 	inc  %i2
                                      <== NOT EXECUTED
40039608:	80 a6 80 01 	cmp  %i2, %g1
                                 <== NOT EXECUTED
4003960c:	0a bf ff f6 	bcs  400395e4 <ramdisk_ioctl+0x10c>
           <== NOT EXECUTED
40039610:	b8 07 20 10 	add  %i4, 0x10, %i4
                           <== NOT EXECUTED
40039614:	10 bf ff d6 	b  4003956c <ramdisk_ioctl+0x94>
              <== NOT EXECUTED
40039618:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1
                          <== NOT EXECUTED
              ramdisk_free(rd);
                                      
4003961c:	40 00 00 08 	call  4003963c <ramdisk_free>
                 <== NOT EXECUTED
40039620:	90 10 00 1b 	mov  %i3, %o0
                                 <== NOT EXECUTED
    errno = EINVAL;
                                                  
40039624:	40 00 8c bc 	call  4005c914 <__errno>
                      <== NOT EXECUTED
40039628:	b0 10 3f ff 	mov  -1, %i0
                                  <== NOT EXECUTED
4003962c:	82 10 20 16 	mov  0x16, %g1
                                <== NOT EXECUTED
40039630:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
}
                                                                    
40039634:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40039638:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED

                                                                     
===============================================================================
40006828 <rtems_bdbuf_get>:
                                          
{
                                                                    
40006828:	9d e3 bf a0 	save  %sp, -96, %sp
                           <== NOT EXECUTED
  _Mutex_Acquire( mutex );
                                           
4000682c:	3b 10 02 36 	sethi  %hi(0x4008d800), %i5
                   <== NOT EXECUTED
40006830:	40 00 55 7a 	call  4001be18 <_Mutex_Acquire>
               <== NOT EXECUTED
40006834:	90 17 61 ac 	or  %i5, 0x1ac, %o0	! 4008d9ac <bdbuf_cache+0x28>
<== NOT EXECUTED
  if (block < dd->block_count)
                                       
40006838:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1
                       <== NOT EXECUTED
4000683c:	80 a6 40 01 	cmp  %i1, %g1
                                 <== NOT EXECUTED
40006840:	1a 80 00 2d 	bcc  400068f4 <rtems_bdbuf_get+0xcc>
          <== NOT EXECUTED
40006844:	b8 10 20 00 	clr  %i4
                                      <== NOT EXECUTED
  if (dd->block_to_media_block_shift >= 0)
                           
40006848:	d2 06 20 30 	ld  [ %i0 + 0x30 ], %o1
                       <== NOT EXECUTED
4000684c:	80 a2 60 00 	cmp  %o1, 0
                                   <== NOT EXECUTED
40006850:	06 80 00 16 	bl  400068a8 <rtems_bdbuf_get+0x80>
           <== NOT EXECUTED
40006854:	93 2e 40 09 	sll  %i1, %o1, %o1
                            <== NOT EXECUTED
    *media_block_ptr = rtems_bdbuf_media_block (dd, block) + dd->start;

40006858:	c2 06 20 18 	ld  [ %i0 + 0x18 ], %g1
                       <== NOT EXECUTED
    bd = rtems_bdbuf_get_buffer_for_access (dd, media_block);
        
4000685c:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
40006860:	7f ff fc 27 	call  400058fc <rtems_bdbuf_get_buffer_for_access>
<== NOT EXECUTED
40006864:	92 02 40 01 	add  %o1, %g1, %o1
                            <== NOT EXECUTED
40006868:	b8 10 00 08 	mov  %o0, %i4
                                 <== NOT EXECUTED
    switch (bd->state)
                                               
4000686c:	d0 02 20 20 	ld  [ %o0 + 0x20 ], %o0
                       <== NOT EXECUTED
40006870:	80 a2 20 02 	cmp  %o0, 2
                                   <== NOT EXECUTED
40006874:	02 80 00 1d 	be  400068e8 <rtems_bdbuf_get+0xc0>
           <== NOT EXECUTED
40006878:	82 10 20 03 	mov  3, %g1
                                   <== NOT EXECUTED
4000687c:	80 a2 20 07 	cmp  %o0, 7
                                   <== NOT EXECUTED
40006880:	12 80 00 23 	bne  4000690c <rtems_bdbuf_get+0xe4>
          <== NOT EXECUTED
40006884:	80 a2 20 01 	cmp  %o0, 1
                                   <== NOT EXECUTED
  bd->state = state;
                                                 
40006888:	82 10 20 04 	mov  4, %g1
                                   <== NOT EXECUTED
4000688c:	c2 27 20 20 	st  %g1, [ %i4 + 0x20 ]
                       <== NOT EXECUTED
40006890:	b0 10 20 00 	clr  %i0
                                      <== NOT EXECUTED
  _Mutex_Release( mutex );
                                           
40006894:	40 00 55 7d 	call  4001be88 <_Mutex_Release>
               <== NOT EXECUTED
40006898:	90 17 61 ac 	or  %i5, 0x1ac, %o0
                           <== NOT EXECUTED
  *bd_ptr = bd;
                                                      
4000689c:	f8 26 80 00 	st  %i4, [ %i2 ]
                              <== NOT EXECUTED
}
                                                                    
400068a0:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
400068a4:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
      ((((uint64_t) block) * dd->block_size) / dd->media_block_size);

400068a8:	d0 06 20 24 	ld  [ %i0 + 0x24 ], %o0
                       <== NOT EXECUTED
400068ac:	d6 06 20 20 	ld  [ %i0 + 0x20 ], %o3
                       <== NOT EXECUTED
400068b0:	92 56 40 08 	umul  %i1, %o0, %o1
                           <== NOT EXECUTED
400068b4:	91 40 00 00 	rd  %y, %o0
                                   <== NOT EXECUTED
400068b8:	40 01 cd c6 	call  40079fd0 <__udivdi3>
                    <== NOT EXECUTED
400068bc:	94 10 20 00 	clr  %o2
                                      <== NOT EXECUTED
    *media_block_ptr = rtems_bdbuf_media_block (dd, block) + dd->start;

400068c0:	c2 06 20 18 	ld  [ %i0 + 0x18 ], %g1
                       <== NOT EXECUTED
    bd = rtems_bdbuf_get_buffer_for_access (dd, media_block);
        
400068c4:	92 02 40 01 	add  %o1, %g1, %o1
                            <== NOT EXECUTED
400068c8:	7f ff fc 0d 	call  400058fc <rtems_bdbuf_get_buffer_for_access>
<== NOT EXECUTED
400068cc:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
400068d0:	b8 10 00 08 	mov  %o0, %i4
                                 <== NOT EXECUTED
    switch (bd->state)
                                               
400068d4:	d0 02 20 20 	ld  [ %o0 + 0x20 ], %o0
                       <== NOT EXECUTED
400068d8:	80 a2 20 02 	cmp  %o0, 2
                                   <== NOT EXECUTED
400068dc:	12 bf ff e9 	bne  40006880 <rtems_bdbuf_get+0x58>
          <== NOT EXECUTED
400068e0:	80 a2 20 07 	cmp  %o0, 7
                                   <== NOT EXECUTED
  bd->state = state;
                                                 
400068e4:	82 10 20 03 	mov  3, %g1
                                   <== NOT EXECUTED
400068e8:	b0 10 20 00 	clr  %i0
                                      <== NOT EXECUTED
400068ec:	10 bf ff ea 	b  40006894 <rtems_bdbuf_get+0x6c>
            <== NOT EXECUTED
400068f0:	c2 27 20 20 	st  %g1, [ %i4 + 0x20 ]
                       <== NOT EXECUTED
400068f4:	90 17 61 ac 	or  %i5, 0x1ac, %o0
                           <== NOT EXECUTED
400068f8:	40 00 55 64 	call  4001be88 <_Mutex_Release>
               <== NOT EXECUTED
400068fc:	b0 10 20 04 	mov  4, %i0
                                   <== NOT EXECUTED
  *bd_ptr = bd;
                                                      
40006900:	f8 26 80 00 	st  %i4, [ %i2 ]
                              <== NOT EXECUTED
}
                                                                    
40006904:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40006908:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
    switch (bd->state)
                                               
4000690c:	02 80 00 04 	be  4000691c <rtems_bdbuf_get+0xf4>
           <== NOT EXECUTED
40006910:	82 10 20 05 	mov  5, %g1
                                   <== NOT EXECUTED
        rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_2);

40006914:	7f ff f7 ce 	call  4000484c <rtems_bdbuf_fatal_with_state>
 <== NOT EXECUTED
40006918:	92 10 20 0a 	mov  0xa, %o1
                                 <== NOT EXECUTED
  bd->state = state;
                                                 
4000691c:	b0 10 20 00 	clr  %i0
                                      <== NOT EXECUTED
40006920:	10 bf ff dd 	b  40006894 <rtems_bdbuf_get+0x6c>
            <== NOT EXECUTED
40006924:	c2 27 20 20 	st  %g1, [ %i4 + 0x20 ]
                       <== NOT EXECUTED

                                                                     
===============================================================================
40007030 <rtems_bdbuf_get_device_stats>:
                             
}
                                                                    

                                                                     
void rtems_bdbuf_get_device_stats (const rtems_disk_device *dd,
      
                                   rtems_blkdev_stats      *stats)
   
{
                                                                    
40007030:	9d e3 bf a0 	save  %sp, -96, %sp
                           <== NOT EXECUTED
40007034:	3b 10 02 36 	sethi  %hi(0x4008d800), %i5
                   <== NOT EXECUTED
40007038:	40 00 53 78 	call  4001be18 <_Mutex_Acquire>
               <== NOT EXECUTED
4000703c:	90 17 61 ac 	or  %i5, 0x1ac, %o0	! 4008d9ac <bdbuf_cache+0x28>
<== NOT EXECUTED
  rtems_bdbuf_lock_cache ();
                                         
  *stats = dd->stats;
                                                
40007040:	92 06 20 44 	add  %i0, 0x44, %o1
                           <== NOT EXECUTED
40007044:	94 10 20 20 	mov  0x20, %o2
                                <== NOT EXECUTED
40007048:	90 10 00 19 	mov  %i1, %o0
                                 <== NOT EXECUTED
4000704c:	40 01 67 e1 	call  40060fd0 <memcpy>
                       <== NOT EXECUTED
40007050:	b0 17 61 ac 	or  %i5, 0x1ac, %i0
                           <== NOT EXECUTED
  _Mutex_Release( mutex );
                                           
40007054:	40 00 53 8d 	call  4001be88 <_Mutex_Release>
               <== NOT EXECUTED
40007058:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED

                                                                     
===============================================================================
40006800 <rtems_bdbuf_init>:
                                         
{
                                                                    
40006800:	9d e3 bf a0 	save  %sp, -96, %sp
                           <== NOT EXECUTED
  eno = pthread_once (&bdbuf_cache.once, rtems_bdbuf_init_once);
     
40006804:	13 10 00 12 	sethi  %hi(0x40004800), %o1
                   <== NOT EXECUTED
40006808:	11 10 02 36 	sethi  %hi(0x4008d800), %o0
                   <== NOT EXECUTED
4000680c:	92 12 60 e4 	or  %o1, 0xe4, %o1
                            <== NOT EXECUTED
40006810:	40 00 4a 70 	call  400191d0 <pthread_once>
                 <== NOT EXECUTED
40006814:	90 12 22 78 	or  %o0, 0x278, %o0
                           <== NOT EXECUTED
  return bdbuf_cache.init_status;
                                    
40006818:	03 10 02 36 	sethi  %hi(0x4008d800), %g1
                   <== NOT EXECUTED
}
                                                                    
4000681c:	f0 00 62 74 	ld  [ %g1 + 0x274 ], %i0	! 4008da74 <bdbuf_cache+0xf0>
<== NOT EXECUTED
40006820:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40006824:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED

                                                                     
===============================================================================
40006ed0 <rtems_bdbuf_purge_dev>:
                                    
{
                                                                    
40006ed0:	9d e3 bf a0 	save  %sp, -96, %sp
                           <== NOT EXECUTED
40006ed4:	ba 10 00 18 	mov  %i0, %i5
                                 <== NOT EXECUTED
  _Mutex_Acquire( mutex );
                                           
40006ed8:	31 10 02 36 	sethi  %hi(0x4008d800), %i0
                   <== NOT EXECUTED
40006edc:	90 16 21 ac 	or  %i0, 0x1ac, %o0	! 4008d9ac <bdbuf_cache+0x28>
<== NOT EXECUTED
40006ee0:	40 00 53 ce 	call  4001be18 <_Mutex_Acquire>
               <== NOT EXECUTED
40006ee4:	b0 10 00 08 	mov  %o0, %i0
                                 <== NOT EXECUTED
  rtems_bdbuf_do_purge_dev (dd);
                                     
40006ee8:	7f ff fb 3b 	call  40005bd4 <rtems_bdbuf_do_purge_dev>
     <== NOT EXECUTED
40006eec:	90 10 00 1d 	mov  %i5, %o0
                                 <== NOT EXECUTED
  _Mutex_Release( mutex );
                                           
40006ef0:	40 00 53 e6 	call  4001be88 <_Mutex_Release>
               <== NOT EXECUTED
40006ef4:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED

                                                                     
===============================================================================
40006928 <rtems_bdbuf_read>:
                                         
{
                                                                    
40006928:	9d e3 bf a0 	save  %sp, -96, %sp
                           <== NOT EXECUTED
  _Mutex_Acquire( mutex );
                                           
4000692c:	37 10 02 36 	sethi  %hi(0x4008d800), %i3
                   <== NOT EXECUTED
40006930:	40 00 55 3a 	call  4001be18 <_Mutex_Acquire>
               <== NOT EXECUTED
40006934:	90 16 e1 ac 	or  %i3, 0x1ac, %o0	! 4008d9ac <bdbuf_cache+0x28>
<== NOT EXECUTED
  if (block < dd->block_count)
                                       
40006938:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1
                       <== NOT EXECUTED
4000693c:	80 a6 40 01 	cmp  %i1, %g1
                                 <== NOT EXECUTED
40006940:	1a 80 00 41 	bcc  40006a44 <rtems_bdbuf_read+0x11c>
        <== NOT EXECUTED
40006944:	ba 10 00 18 	mov  %i0, %i5
                                 <== NOT EXECUTED
  if (dd->block_to_media_block_shift >= 0)
                           
40006948:	d2 06 20 30 	ld  [ %i0 + 0x30 ], %o1
                       <== NOT EXECUTED
4000694c:	80 a2 60 00 	cmp  %o1, 0
                                   <== NOT EXECUTED
40006950:	06 80 00 27 	bl  400069ec <rtems_bdbuf_read+0xc4>
          <== NOT EXECUTED
40006954:	93 2e 40 09 	sll  %i1, %o1, %o1
                            <== NOT EXECUTED
    *media_block_ptr = rtems_bdbuf_media_block (dd, block) + dd->start;

40006958:	c2 07 60 18 	ld  [ %i5 + 0x18 ], %g1
                       <== NOT EXECUTED
    bd = rtems_bdbuf_get_buffer_for_access (dd, media_block);
        
4000695c:	90 10 00 1d 	mov  %i5, %o0
                                 <== NOT EXECUTED
40006960:	7f ff fb e7 	call  400058fc <rtems_bdbuf_get_buffer_for_access>
<== NOT EXECUTED
40006964:	92 02 40 01 	add  %o1, %g1, %o1
                            <== NOT EXECUTED
40006968:	b8 10 00 08 	mov  %o0, %i4
                                 <== NOT EXECUTED
    switch (bd->state)
                                               
4000696c:	d0 02 20 20 	ld  [ %o0 + 0x20 ], %o0
                       <== NOT EXECUTED
40006970:	80 a2 20 02 	cmp  %o0, 2
                                   <== NOT EXECUTED
40006974:	22 80 00 2e 	be,a   40006a2c <rtems_bdbuf_read+0x104>
      <== NOT EXECUTED
40006978:	c2 07 60 44 	ld  [ %i5 + 0x44 ], %g1
                       <== NOT EXECUTED
4000697c:	80 a2 20 07 	cmp  %o0, 7
                                   <== NOT EXECUTED
40006980:	12 80 00 38 	bne  40006a60 <rtems_bdbuf_read+0x138>
        <== NOT EXECUTED
40006984:	80 a2 20 01 	cmp  %o0, 1
                                   <== NOT EXECUTED
        ++dd->stats.read_hits;
                                       
40006988:	c2 07 60 44 	ld  [ %i5 + 0x44 ], %g1
                       <== NOT EXECUTED
4000698c:	82 00 60 01 	inc  %g1
                                      <== NOT EXECUTED
40006990:	c2 27 60 44 	st  %g1, [ %i5 + 0x44 ]
                       <== NOT EXECUTED
  bd->state = state;
                                                 
40006994:	82 10 20 04 	mov  4, %g1
                                   <== NOT EXECUTED
40006998:	c2 27 20 20 	st  %g1, [ %i4 + 0x20 ]
                       <== NOT EXECUTED
4000699c:	b0 10 20 00 	clr  %i0
                                      <== NOT EXECUTED
  if (bdbuf_cache.read_ahead_task != 0
                               
400069a0:	21 10 02 36 	sethi  %hi(0x4008d800), %l0
                   <== NOT EXECUTED
400069a4:	a0 14 21 84 	or  %l0, 0x184, %l0	! 4008d984 <bdbuf_cache>
  <== NOT EXECUTED
400069a8:	d0 04 20 dc 	ld  [ %l0 + 0xdc ], %o0
                       <== NOT EXECUTED
400069ac:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
400069b0:	02 80 00 0a 	be  400069d8 <rtems_bdbuf_read+0xb0>
          <== NOT EXECUTED
400069b4:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
      && dd->read_ahead.trigger == block
                             
400069b8:	c2 07 60 6c 	ld  [ %i5 + 0x6c ], %g1
                       <== NOT EXECUTED
400069bc:	80 a6 40 01 	cmp  %i1, %g1
                                 <== NOT EXECUTED
400069c0:	12 80 00 06 	bne  400069d8 <rtems_bdbuf_read+0xb0>
         <== NOT EXECUTED
400069c4:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
      && !rtems_bdbuf_is_read_ahead_active (dd))
                     
400069c8:	c2 07 60 64 	ld  [ %i5 + 0x64 ], %g1
                       <== NOT EXECUTED
400069cc:	80 a0 60 00 	cmp  %g1, 0
                                   <== NOT EXECUTED
400069d0:	22 80 00 4c 	be,a   40006b00 <rtems_bdbuf_read+0x1d8>
      <== NOT EXECUTED
400069d4:	c2 04 20 e0 	ld  [ %l0 + 0xe0 ], %g1
                       <== NOT EXECUTED
  _Mutex_Release( mutex );
                                           
400069d8:	40 00 55 2c 	call  4001be88 <_Mutex_Release>
               <== NOT EXECUTED
400069dc:	90 16 e1 ac 	or  %i3, 0x1ac, %o0
                           <== NOT EXECUTED
  *bd_ptr = bd;
                                                      
400069e0:	f8 26 80 00 	st  %i4, [ %i2 ]
                              <== NOT EXECUTED
}
                                                                    
400069e4:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
400069e8:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
      ((((uint64_t) block) * dd->block_size) / dd->media_block_size);

400069ec:	d0 06 20 24 	ld  [ %i0 + 0x24 ], %o0
                       <== NOT EXECUTED
400069f0:	d6 06 20 20 	ld  [ %i0 + 0x20 ], %o3
                       <== NOT EXECUTED
400069f4:	92 56 40 08 	umul  %i1, %o0, %o1
                           <== NOT EXECUTED
400069f8:	91 40 00 00 	rd  %y, %o0
                                   <== NOT EXECUTED
400069fc:	40 01 cd 75 	call  40079fd0 <__udivdi3>
                    <== NOT EXECUTED
40006a00:	94 10 20 00 	clr  %o2
                                      <== NOT EXECUTED
    *media_block_ptr = rtems_bdbuf_media_block (dd, block) + dd->start;

40006a04:	c2 07 60 18 	ld  [ %i5 + 0x18 ], %g1
                       <== NOT EXECUTED
    bd = rtems_bdbuf_get_buffer_for_access (dd, media_block);
        
40006a08:	92 02 40 01 	add  %o1, %g1, %o1
                            <== NOT EXECUTED
40006a0c:	7f ff fb bc 	call  400058fc <rtems_bdbuf_get_buffer_for_access>
<== NOT EXECUTED
40006a10:	90 10 00 1d 	mov  %i5, %o0
                                 <== NOT EXECUTED
40006a14:	b8 10 00 08 	mov  %o0, %i4
                                 <== NOT EXECUTED
    switch (bd->state)
                                               
40006a18:	d0 02 20 20 	ld  [ %o0 + 0x20 ], %o0
                       <== NOT EXECUTED
40006a1c:	80 a2 20 02 	cmp  %o0, 2
                                   <== NOT EXECUTED
40006a20:	12 bf ff d8 	bne  40006980 <rtems_bdbuf_read+0x58>
         <== NOT EXECUTED
40006a24:	80 a2 20 07 	cmp  %o0, 7
                                   <== NOT EXECUTED
        ++dd->stats.read_hits;
                                       
40006a28:	c2 07 60 44 	ld  [ %i5 + 0x44 ], %g1
                       <== NOT EXECUTED
40006a2c:	82 00 60 01 	inc  %g1
                                      <== NOT EXECUTED
40006a30:	c2 27 60 44 	st  %g1, [ %i5 + 0x44 ]
                       <== NOT EXECUTED
  bd->state = state;
                                                 
40006a34:	b0 10 20 00 	clr  %i0
                                      <== NOT EXECUTED
40006a38:	82 10 20 03 	mov  3, %g1
                                   <== NOT EXECUTED
40006a3c:	10 bf ff d9 	b  400069a0 <rtems_bdbuf_read+0x78>
           <== NOT EXECUTED
40006a40:	c2 27 20 20 	st  %g1, [ %i4 + 0x20 ]
                       <== NOT EXECUTED
  rtems_bdbuf_buffer   *bd = NULL;
                                   
40006a44:	b8 10 20 00 	clr  %i4
                                      <== NOT EXECUTED
40006a48:	90 16 e1 ac 	or  %i3, 0x1ac, %o0
                           <== NOT EXECUTED
40006a4c:	40 00 55 0f 	call  4001be88 <_Mutex_Release>
               <== NOT EXECUTED
40006a50:	b0 10 20 04 	mov  4, %i0
                                   <== NOT EXECUTED
  *bd_ptr = bd;
                                                      
40006a54:	f8 26 80 00 	st  %i4, [ %i2 ]
                              <== NOT EXECUTED
}
                                                                    
40006a58:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40006a5c:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
    switch (bd->state)
                                               
40006a60:	22 80 00 04 	be,a   40006a70 <rtems_bdbuf_read+0x148>
      <== NOT EXECUTED
40006a64:	c2 07 60 48 	ld  [ %i5 + 0x48 ], %g1
                       <== NOT EXECUTED
        rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_4);

40006a68:	7f ff f7 79 	call  4000484c <rtems_bdbuf_fatal_with_state>
 <== NOT EXECUTED
40006a6c:	92 10 20 0b 	mov  0xb, %o1
                                 <== NOT EXECUTED
        ++dd->stats.read_misses;
                                     
40006a70:	82 00 60 01 	inc  %g1
                                      <== NOT EXECUTED
40006a74:	c2 27 60 48 	st  %g1, [ %i5 + 0x48 ]
                       <== NOT EXECUTED
  if (dd->read_ahead.trigger != block)
                               
40006a78:	c2 07 60 6c 	ld  [ %i5 + 0x6c ], %g1
                       <== NOT EXECUTED
40006a7c:	80 a6 40 01 	cmp  %i1, %g1
                                 <== NOT EXECUTED
40006a80:	02 80 00 0f 	be  40006abc <rtems_bdbuf_read+0x194>
         <== NOT EXECUTED
40006a84:	94 10 20 01 	mov  1, %o2
                                   <== NOT EXECUTED
40006a88:	c2 07 60 64 	ld  [ %i5 + 0x64 ], %g1
                       <== NOT EXECUTED
  if (rtems_bdbuf_is_read_ahead_active (dd))
                         
40006a8c:	80 a0 60 00 	cmp  %g1, 0
                                   <== NOT EXECUTED
40006a90:	02 80 00 07 	be  40006aac <rtems_bdbuf_read+0x184>
         <== NOT EXECUTED
40006a94:	84 06 60 01 	add  %i1, 1, %g2
                              <== NOT EXECUTED
  previous       = the_node->previous;
                               
40006a98:	c4 07 60 68 	ld  [ %i5 + 0x68 ], %g2
                       <== NOT EXECUTED
  next->previous = previous;
                                         
40006a9c:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]
                          <== NOT EXECUTED
  previous->next = next;
                                             
40006aa0:	c2 20 80 00 	st  %g1, [ %g2 ]
                              <== NOT EXECUTED
  node->next = NULL;
                                                 
40006aa4:	c0 27 60 64 	clr  [ %i5 + 0x64 ]
                           <== NOT EXECUTED
    dd->read_ahead.trigger = block + 1;
                              
40006aa8:	84 06 60 01 	add  %i1, 1, %g2
                              <== NOT EXECUTED
    dd->read_ahead.next = block + 2;
                                 
40006aac:	82 06 60 02 	add  %i1, 2, %g1
                              <== NOT EXECUTED
    dd->read_ahead.trigger = block + 1;
                              
40006ab0:	c4 27 60 6c 	st  %g2, [ %i5 + 0x6c ]
                       <== NOT EXECUTED
    dd->read_ahead.next = block + 2;
                                 
40006ab4:	c2 27 60 70 	st  %g1, [ %i5 + 0x70 ]
                       <== NOT EXECUTED
        sc = rtems_bdbuf_execute_read_request (dd, bd, 1);
           
40006ab8:	94 10 20 01 	mov  1, %o2
                                   <== NOT EXECUTED
40006abc:	92 10 00 1c 	mov  %i4, %o1
                                 <== NOT EXECUTED
40006ac0:	7f ff fd 67 	call  4000605c <rtems_bdbuf_execute_read_request>
<== NOT EXECUTED
40006ac4:	90 10 00 1d 	mov  %i5, %o0
                                 <== NOT EXECUTED
        if (sc == RTEMS_SUCCESSFUL)
                                  
40006ac8:	b0 92 20 00 	orcc  %o0, 0, %i0
                             <== NOT EXECUTED
40006acc:	32 bf ff b5 	bne,a   400069a0 <rtems_bdbuf_read+0x78>
      <== NOT EXECUTED
40006ad0:	b8 10 20 00 	clr  %i4
                                      <== NOT EXECUTED
  next           = the_node->next;
                                   
40006ad4:	c8 07 00 00 	ld  [ %i4 ], %g4
                              <== NOT EXECUTED
  previous       = the_node->previous;
                               
40006ad8:	c6 07 20 04 	ld  [ %i4 + 4 ], %g3
                          <== NOT EXECUTED
  bd->state = state;
                                                 
40006adc:	82 10 20 03 	mov  3, %g1
                                   <== NOT EXECUTED
40006ae0:	c2 27 20 20 	st  %g1, [ %i4 + 0x20 ]
                       <== NOT EXECUTED
40006ae4:	c4 07 20 28 	ld  [ %i4 + 0x28 ], %g2
                       <== NOT EXECUTED
  next->previous = previous;
                                         
40006ae8:	c6 21 20 04 	st  %g3, [ %g4 + 4 ]
                          <== NOT EXECUTED
  ++bd->group->users;
                                                
40006aec:	c2 00 a0 0c 	ld  [ %g2 + 0xc ], %g1
                        <== NOT EXECUTED
  previous->next = next;
                                             
40006af0:	c8 20 c0 00 	st  %g4, [ %g3 ]
                              <== NOT EXECUTED
40006af4:	82 00 60 01 	inc  %g1
                                      <== NOT EXECUTED
40006af8:	10 bf ff aa 	b  400069a0 <rtems_bdbuf_read+0x78>
           <== NOT EXECUTED
40006afc:	c2 20 a0 0c 	st  %g1, [ %g2 + 0xc ]
                        <== NOT EXECUTED
    if (rtems_chain_is_empty (chain))
                                
40006b00:	b2 04 20 e4 	add  %l0, 0xe4, %i1
                           <== NOT EXECUTED
40006b04:	80 a0 40 19 	cmp  %g1, %i1
                                 <== NOT EXECUTED
40006b08:	02 80 00 09 	be  40006b2c <rtems_bdbuf_read+0x204>
         <== NOT EXECUTED
40006b0c:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  old_last = tail->previous;
                                         
40006b10:	c2 04 20 e8 	ld  [ %l0 + 0xe8 ], %g1
                       <== NOT EXECUTED
  the_node->next = tail;
                                             
40006b14:	f2 27 60 64 	st  %i1, [ %i5 + 0x64 ]
                       <== NOT EXECUTED
    rtems_chain_append_unprotected (chain, &dd->read_ahead.node);
    
40006b18:	84 07 60 64 	add  %i5, 0x64, %g2
                           <== NOT EXECUTED
  tail->previous = the_node;
                                         
40006b1c:	c4 24 20 e8 	st  %g2, [ %l0 + 0xe8 ]
                       <== NOT EXECUTED
  old_last->next = the_node;
                                         
40006b20:	c4 20 40 00 	st  %g2, [ %g1 ]
                              <== NOT EXECUTED
  the_node->previous = old_last;
                                     
40006b24:	10 bf ff ad 	b  400069d8 <rtems_bdbuf_read+0xb0>
           <== NOT EXECUTED
40006b28:	c2 27 60 68 	st  %g1, [ %i5 + 0x68 ]
                       <== NOT EXECUTED
      sc = rtems_event_send (bdbuf_cache.read_ahead_task,
            
40006b2c:	40 00 4a 33 	call  400193f8 <rtems_event_send>
             <== NOT EXECUTED
40006b30:	92 10 20 02 	mov  2, %o1
                                   <== NOT EXECUTED
      if (sc != RTEMS_SUCCESSFUL)
                                    
40006b34:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
40006b38:	22 bf ff f7 	be,a   40006b14 <rtems_bdbuf_read+0x1ec>
      <== NOT EXECUTED
40006b3c:	c2 04 20 e8 	ld  [ %l0 + 0xe8 ], %g1
                       <== NOT EXECUTED
        rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_RA_WAKE_UP);
            
40006b40:	7f ff f7 2c 	call  400047f0 <rtems_bdbuf_fatal>
            <== NOT EXECUTED
40006b44:	90 10 20 05 	mov  5, %o0
                                   <== NOT EXECUTED
40006b48:	01 00 00 00 	nop 
                                          <== NOT EXECUTED

                                                                     
===============================================================================
40006b4c <rtems_bdbuf_release>:
                                      
{
                                                                    
40006b4c:	9d e3 bf a0 	save  %sp, -96, %sp
                           <== NOT EXECUTED
  if (bd == NULL)
                                                    
40006b50:	80 a6 20 00 	cmp  %i0, 0
                                   <== NOT EXECUTED
40006b54:	02 80 00 2f 	be  40006c10 <rtems_bdbuf_release+0xc4>
       <== NOT EXECUTED
40006b58:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  _Mutex_Acquire( mutex );
                                           
40006b5c:	3b 10 02 36 	sethi  %hi(0x4008d800), %i5
                   <== NOT EXECUTED
40006b60:	40 00 54 ae 	call  4001be18 <_Mutex_Acquire>
               <== NOT EXECUTED
40006b64:	90 17 61 ac 	or  %i5, 0x1ac, %o0	! 4008d9ac <bdbuf_cache+0x28>
<== NOT EXECUTED
  switch (bd->state)
                                                 
40006b68:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0
                       <== NOT EXECUTED
40006b6c:	80 a2 20 04 	cmp  %o0, 4
                                   <== NOT EXECUTED
40006b70:	02 80 00 21 	be  40006bf4 <rtems_bdbuf_release+0xa8>
       <== NOT EXECUTED
40006b74:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
40006b78:	18 80 00 28 	bgu  40006c18 <rtems_bdbuf_release+0xcc>
      <== NOT EXECUTED
40006b7c:	80 a2 20 06 	cmp  %o0, 6
                                   <== NOT EXECUTED
40006b80:	80 a2 20 03 	cmp  %o0, 3
                                   <== NOT EXECUTED
40006b84:	12 80 00 35 	bne  40006c58 <rtems_bdbuf_release+0x10c>
     <== NOT EXECUTED
40006b88:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
40006b8c:	c4 06 20 28 	ld  [ %i0 + 0x28 ], %g2
                       <== NOT EXECUTED
  --bd->group->users;
                                                
40006b90:	c2 00 a0 0c 	ld  [ %g2 + 0xc ], %g1
                        <== NOT EXECUTED
40006b94:	82 00 7f ff 	add  %g1, -1, %g1
                             <== NOT EXECUTED
40006b98:	c2 20 a0 0c 	st  %g1, [ %g2 + 0xc ]
                        <== NOT EXECUTED
  bd->state = state;
                                                 
40006b9c:	82 10 20 02 	mov  2, %g1
                                   <== NOT EXECUTED
  old_last = tail->previous;
                                         
40006ba0:	11 10 02 36 	sethi  %hi(0x4008d800), %o0
                   <== NOT EXECUTED
40006ba4:	c2 26 20 20 	st  %g1, [ %i0 + 0x20 ]
                       <== NOT EXECUTED
40006ba8:	90 12 21 84 	or  %o0, 0x184, %o0
                           <== NOT EXECUTED
40006bac:	c2 02 20 68 	ld  [ %o0 + 0x68 ], %g1
                       <== NOT EXECUTED
  the_node->next = tail;
                                             
40006bb0:	84 02 20 64 	add  %o0, 0x64, %g2
                           <== NOT EXECUTED
40006bb4:	c4 26 00 00 	st  %g2, [ %i0 ]
                              <== NOT EXECUTED
  tail->previous = the_node;
                                         
40006bb8:	f0 22 20 68 	st  %i0, [ %o0 + 0x68 ]
                       <== NOT EXECUTED
  old_last->next = the_node;
                                         
40006bbc:	f0 20 40 00 	st  %i0, [ %g1 ]
                              <== NOT EXECUTED
  the_node->previous = old_last;
                                     
40006bc0:	c2 26 20 04 	st  %g1, [ %i0 + 4 ]
                          <== NOT EXECUTED
  if (bd->waiters)
                                                   
40006bc4:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1
                       <== NOT EXECUTED
40006bc8:	80 a0 60 00 	cmp  %g1, 0
                                   <== NOT EXECUTED
40006bcc:	22 80 00 1c 	be,a   40006c3c <rtems_bdbuf_release+0xf0>
    <== NOT EXECUTED
40006bd0:	c2 02 20 b4 	ld  [ %o0 + 0xb4 ], %g1
                       <== NOT EXECUTED
  if (waiters->count > 0)
                                            
40006bd4:	c2 02 20 84 	ld  [ %o0 + 0x84 ], %g1
                       <== NOT EXECUTED
40006bd8:	80 a0 60 00 	cmp  %g1, 0
                                   <== NOT EXECUTED
40006bdc:	22 80 00 09 	be,a   40006c00 <rtems_bdbuf_release+0xb4>
    <== NOT EXECUTED
40006be0:	90 17 61 ac 	or  %i5, 0x1ac, %o0
                           <== NOT EXECUTED
  _Condition_Broadcast( condition_variable );
                        
40006be4:	40 00 4d 15 	call  4001a038 <_Condition_Broadcast>
         <== NOT EXECUTED
40006be8:	90 02 20 88 	add  %o0, 0x88, %o0
                           <== NOT EXECUTED
  _Mutex_Release( mutex );
                                           
40006bec:	10 80 00 05 	b  40006c00 <rtems_bdbuf_release+0xb4>
        <== NOT EXECUTED
40006bf0:	90 17 61 ac 	or  %i5, 0x1ac, %o0
                           <== NOT EXECUTED
      rtems_bdbuf_add_to_modified_list_after_access (bd);
            
40006bf4:	7f ff f8 c1 	call  40004ef8 <rtems_bdbuf_add_to_modified_list_after_access>
<== NOT EXECUTED
40006bf8:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
40006bfc:	90 17 61 ac 	or  %i5, 0x1ac, %o0
                           <== NOT EXECUTED
40006c00:	40 00 54 a2 	call  4001be88 <_Mutex_Release>
               <== NOT EXECUTED
40006c04:	b0 10 20 00 	clr  %i0
                                      <== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
                                           
40006c08:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40006c0c:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
}
                                                                    
40006c10:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40006c14:	91 e8 20 09 	restore  %g0, 9, %o0
                          <== NOT EXECUTED
  switch (bd->state)
                                                 
40006c18:	18 80 00 10 	bgu  40006c58 <rtems_bdbuf_release+0x10c>
     <== NOT EXECUTED
40006c1c:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
      rtems_bdbuf_discard_buffer_after_access (bd);
                  
40006c20:	7f ff fe d6 	call  40006778 <rtems_bdbuf_discard_buffer_after_access>
<== NOT EXECUTED
40006c24:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
40006c28:	90 17 61 ac 	or  %i5, 0x1ac, %o0
                           <== NOT EXECUTED
40006c2c:	40 00 54 97 	call  4001be88 <_Mutex_Release>
               <== NOT EXECUTED
40006c30:	b0 10 20 00 	clr  %i0
                                      <== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
                                           
40006c34:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40006c38:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
  if (waiters->count > 0)
                                            
40006c3c:	80 a0 60 00 	cmp  %g1, 0
                                   <== NOT EXECUTED
40006c40:	22 bf ff f0 	be,a   40006c00 <rtems_bdbuf_release+0xb4>
    <== NOT EXECUTED
40006c44:	90 17 61 ac 	or  %i5, 0x1ac, %o0
                           <== NOT EXECUTED
  _Condition_Broadcast( condition_variable );
                        
40006c48:	40 00 4c fc 	call  4001a038 <_Condition_Broadcast>
         <== NOT EXECUTED
40006c4c:	90 02 20 b8 	add  %o0, 0xb8, %o0
                           <== NOT EXECUTED
  _Mutex_Release( mutex );
                                           
40006c50:	10 bf ff ec 	b  40006c00 <rtems_bdbuf_release+0xb4>
        <== NOT EXECUTED
40006c54:	90 17 61 ac 	or  %i5, 0x1ac, %o0
                           <== NOT EXECUTED
      rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_0);

40006c58:	7f ff f6 fd 	call  4000484c <rtems_bdbuf_fatal_with_state>
 <== NOT EXECUTED
40006c5c:	92 10 20 09 	mov  9, %o1
                                   <== NOT EXECUTED
40006c60:	01 00 00 00 	nop 
                                          <== NOT EXECUTED

                                                                     
===============================================================================
40006c64 <rtems_bdbuf_release_modified>:
                             
{
                                                                    
40006c64:	9d e3 bf a0 	save  %sp, -96, %sp
                           <== NOT EXECUTED
  if (bd == NULL)
                                                    
40006c68:	80 a6 20 00 	cmp  %i0, 0
                                   <== NOT EXECUTED
40006c6c:	02 80 00 1b 	be  40006cd8 <rtems_bdbuf_release_modified+0x74>
<== NOT EXECUTED
40006c70:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  _Mutex_Acquire( mutex );
                                           
40006c74:	3b 10 02 36 	sethi  %hi(0x4008d800), %i5
                   <== NOT EXECUTED
40006c78:	40 00 54 68 	call  4001be18 <_Mutex_Acquire>
               <== NOT EXECUTED
40006c7c:	90 17 61 ac 	or  %i5, 0x1ac, %o0	! 4008d9ac <bdbuf_cache+0x28>
<== NOT EXECUTED
  switch (bd->state)
                                                 
40006c80:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0
                       <== NOT EXECUTED
40006c84:	80 a2 20 03 	cmp  %o0, 3
                                   <== NOT EXECUTED
40006c88:	0a 80 00 16 	bcs  40006ce0 <rtems_bdbuf_release_modified+0x7c>
<== NOT EXECUTED
40006c8c:	80 a2 20 05 	cmp  %o0, 5
                                   <== NOT EXECUTED
40006c90:	08 80 00 0b 	bleu  40006cbc <rtems_bdbuf_release_modified+0x58>
<== NOT EXECUTED
40006c94:	80 a2 20 06 	cmp  %o0, 6
                                   <== NOT EXECUTED
40006c98:	12 80 00 12 	bne  40006ce0 <rtems_bdbuf_release_modified+0x7c>
<== NOT EXECUTED
40006c9c:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
      rtems_bdbuf_discard_buffer_after_access (bd);
                  
40006ca0:	7f ff fe b6 	call  40006778 <rtems_bdbuf_discard_buffer_after_access>
<== NOT EXECUTED
40006ca4:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
  _Mutex_Release( mutex );
                                           
40006ca8:	90 17 61 ac 	or  %i5, 0x1ac, %o0
                           <== NOT EXECUTED
40006cac:	40 00 54 77 	call  4001be88 <_Mutex_Release>
               <== NOT EXECUTED
40006cb0:	b0 10 20 00 	clr  %i0
                                      <== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
                                           
40006cb4:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40006cb8:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
      rtems_bdbuf_add_to_modified_list_after_access (bd);
            
40006cbc:	7f ff f8 8f 	call  40004ef8 <rtems_bdbuf_add_to_modified_list_after_access>
<== NOT EXECUTED
40006cc0:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
40006cc4:	90 17 61 ac 	or  %i5, 0x1ac, %o0
                           <== NOT EXECUTED
40006cc8:	40 00 54 70 	call  4001be88 <_Mutex_Release>
               <== NOT EXECUTED
40006ccc:	b0 10 20 00 	clr  %i0
                                      <== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
                                           
40006cd0:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40006cd4:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
}
                                                                    
40006cd8:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40006cdc:	91 e8 20 09 	restore  %g0, 9, %o0
                          <== NOT EXECUTED
      rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_6);

40006ce0:	7f ff f6 db 	call  4000484c <rtems_bdbuf_fatal_with_state>
 <== NOT EXECUTED
40006ce4:	92 10 20 0d 	mov  0xd, %o1
                                 <== NOT EXECUTED
40006ce8:	01 00 00 00 	nop 
                                          <== NOT EXECUTED

                                                                     
===============================================================================
4000705c <rtems_bdbuf_reset_device_stats>:
                           
  rtems_bdbuf_unlock_cache ();
                                       
}
                                                                    

                                                                     
void rtems_bdbuf_reset_device_stats (rtems_disk_device *dd)
          
{
                                                                    
4000705c:	9d e3 bf a0 	save  %sp, -96, %sp
                           <== NOT EXECUTED
  _Mutex_Acquire( mutex );
                                           
40007060:	3b 10 02 36 	sethi  %hi(0x4008d800), %i5
                   <== NOT EXECUTED
40007064:	40 00 53 6d 	call  4001be18 <_Mutex_Acquire>
               <== NOT EXECUTED
40007068:	90 17 61 ac 	or  %i5, 0x1ac, %o0	! 4008d9ac <bdbuf_cache+0x28>
<== NOT EXECUTED
  rtems_bdbuf_lock_cache ();
                                         
  memset (&dd->stats, 0, sizeof(dd->stats));
                         
4000706c:	94 10 20 20 	mov  0x20, %o2
                                <== NOT EXECUTED
40007070:	92 10 20 00 	clr  %o1
                                      <== NOT EXECUTED
40007074:	90 06 20 44 	add  %i0, 0x44, %o0
                           <== NOT EXECUTED
40007078:	40 01 68 60 	call  400611f8 <memset>
                       <== NOT EXECUTED
4000707c:	b0 17 61 ac 	or  %i5, 0x1ac, %i0
                           <== NOT EXECUTED
  _Mutex_Release( mutex );
                                           
40007080:	40 00 53 82 	call  4001be88 <_Mutex_Release>
               <== NOT EXECUTED
40007084:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED

                                                                     
===============================================================================
40006ef8 <rtems_bdbuf_set_block_size>:
                               
{
                                                                    
40006ef8:	9d e3 bf a0 	save  %sp, -96, %sp
                           <== NOT EXECUTED
  if (sync)
                                                          
40006efc:	80 a6 a0 00 	cmp  %i2, 0
                                   <== NOT EXECUTED
40006f00:	12 80 00 48 	bne  40007020 <rtems_bdbuf_set_block_size+0x128>
<== NOT EXECUTED
40006f04:	ba 10 00 18 	mov  %i0, %i5
                                 <== NOT EXECUTED
  _Mutex_Acquire( mutex );
                                           
40006f08:	39 10 02 36 	sethi  %hi(0x4008d800), %i4
                   <== NOT EXECUTED
40006f0c:	40 00 53 c3 	call  4001be18 <_Mutex_Acquire>
               <== NOT EXECUTED
40006f10:	90 17 21 ac 	or  %i4, 0x1ac, %o0	! 4008d9ac <bdbuf_cache+0x28>
<== NOT EXECUTED
  if (block_size > 0)
                                                
40006f14:	80 a6 60 00 	cmp  %i1, 0
                                   <== NOT EXECUTED
40006f18:	02 80 00 3e 	be  40007010 <rtems_bdbuf_set_block_size+0x118>
<== NOT EXECUTED
40006f1c:	b0 10 20 0a 	mov  0xa, %i0
                                 <== NOT EXECUTED
  if (size > bdbuf_config.buffer_max)
                                
40006f20:	03 10 01 f1 	sethi  %hi(0x4007c400), %g1
                   <== NOT EXECUTED
40006f24:	82 10 62 e0 	or  %g1, 0x2e0, %g1	! 4007c6e0 <rtems_bdbuf_configuration>
<== NOT EXECUTED
40006f28:	c4 00 60 28 	ld  [ %g1 + 0x28 ], %g2
                       <== NOT EXECUTED
40006f2c:	80 a6 40 02 	cmp  %i1, %g2
                                 <== NOT EXECUTED
40006f30:	18 80 00 38 	bgu  40007010 <rtems_bdbuf_set_block_size+0x118>
<== NOT EXECUTED
40006f34:	86 06 7f ff 	add  %i1, -1, %g3
                             <== NOT EXECUTED
  bufs_per_size = ((size - 1) / bdbuf_config.buffer_min) + 1;
        
40006f38:	81 80 20 00 	wr  %g0, %y
                                   <== NOT EXECUTED
40006f3c:	c4 00 60 24 	ld  [ %g1 + 0x24 ], %g2
                       <== NOT EXECUTED
40006f40:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
40006f44:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
40006f48:	84 70 c0 02 	udiv  %g3, %g2, %g2
                           <== NOT EXECUTED
40006f4c:	84 00 a0 01 	inc  %g2
                                      <== NOT EXECUTED
  for (bds_per_size = 1;
                                             
40006f50:	80 a0 a0 01 	cmp  %g2, 1
                                   <== NOT EXECUTED
40006f54:	08 80 00 06 	bleu  40006f6c <rtems_bdbuf_set_block_size+0x74>
<== NOT EXECUTED
40006f58:	82 10 20 01 	mov  1, %g1
                                   <== NOT EXECUTED
       bds_per_size <<= 1)
                                           
40006f5c:	83 28 60 01 	sll  %g1, 1, %g1
                              <== NOT EXECUTED
  for (bds_per_size = 1;
                                             
40006f60:	80 a0 80 01 	cmp  %g2, %g1
                                 <== NOT EXECUTED
40006f64:	38 bf ff ff 	bgu,a   40006f60 <rtems_bdbuf_set_block_size+0x68>
<== NOT EXECUTED
40006f68:	83 28 60 01 	sll  %g1, 1, %g1
                              <== NOT EXECUTED
  return bdbuf_cache.max_bds_per_group / bds_per_size;
               
40006f6c:	05 10 02 36 	sethi  %hi(0x4008d800), %g2
                   <== NOT EXECUTED
40006f70:	81 80 20 00 	wr  %g0, %y
                                   <== NOT EXECUTED
40006f74:	f4 00 a1 a4 	ld  [ %g2 + 0x1a4 ], %i2
                      <== NOT EXECUTED
40006f78:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
40006f7c:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
40006f80:	b4 76 80 01 	udiv  %i2, %g1, %i2
                           <== NOT EXECUTED
    if (bds_per_group != 0)
                                          
40006f84:	80 a6 a0 00 	cmp  %i2, 0
                                   <== NOT EXECUTED
40006f88:	02 80 00 22 	be  40007010 <rtems_bdbuf_set_block_size+0x118>
<== NOT EXECUTED
40006f8c:	b0 10 20 0a 	mov  0xa, %i0
                                 <== NOT EXECUTED
      uint32_t media_blocks_per_block = block_size / dd->media_block_size;

40006f90:	f6 07 60 20 	ld  [ %i5 + 0x20 ], %i3
                       <== NOT EXECUTED
40006f94:	81 80 20 00 	wr  %g0, %y
                                   <== NOT EXECUTED
40006f98:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
40006f9c:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
40006fa0:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
40006fa4:	86 76 40 1b 	udiv  %i1, %i3, %g3
                           <== NOT EXECUTED
      while ((one << block_to_media_block_shift) < media_blocks_per_block)

40006fa8:	80 a0 e0 01 	cmp  %g3, 1
                                   <== NOT EXECUTED
40006fac:	08 80 00 09 	bleu  40006fd0 <rtems_bdbuf_set_block_size+0xd8>
<== NOT EXECUTED
40006fb0:	82 10 20 00 	clr  %g1
                                      <== NOT EXECUTED
40006fb4:	88 10 20 01 	mov  1, %g4
                                   <== NOT EXECUTED
        ++block_to_media_block_shift;
                                
40006fb8:	82 00 60 01 	inc  %g1
                                      <== NOT EXECUTED
      while ((one << block_to_media_block_shift) < media_blocks_per_block)

40006fbc:	85 29 00 01 	sll  %g4, %g1, %g2
                            <== NOT EXECUTED
40006fc0:	80 a0 80 03 	cmp  %g2, %g3
                                 <== NOT EXECUTED
40006fc4:	2a bf ff fe 	bcs,a   40006fbc <rtems_bdbuf_set_block_size+0xc4>
<== NOT EXECUTED
40006fc8:	82 00 60 01 	inc  %g1
                                      <== NOT EXECUTED
40006fcc:	b7 2e c0 01 	sll  %i3, %g1, %i3
                            <== NOT EXECUTED
      if ((dd->media_block_size << block_to_media_block_shift) != block_size)

40006fd0:	80 a6 40 1b 	cmp  %i1, %i3
                                 <== NOT EXECUTED
40006fd4:	32 80 00 02 	bne,a   40006fdc <rtems_bdbuf_set_block_size+0xe4>
<== NOT EXECUTED
40006fd8:	82 10 3f ff 	mov  -1, %g1
                                  <== NOT EXECUTED
      dd->block_count = dd->size / media_blocks_per_block;
           
40006fdc:	81 80 20 00 	wr  %g0, %y
                                   <== NOT EXECUTED
40006fe0:	c4 07 60 1c 	ld  [ %i5 + 0x1c ], %g2
                       <== NOT EXECUTED
40006fe4:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
40006fe8:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
40006fec:	84 70 80 03 	udiv  %g2, %g3, %g2
                           <== NOT EXECUTED
      dd->block_size = block_size;
                                   
40006ff0:	f2 27 60 24 	st  %i1, [ %i5 + 0x24 ]
                       <== NOT EXECUTED
      rtems_bdbuf_do_purge_dev (dd);
                                 
40006ff4:	90 10 00 1d 	mov  %i5, %o0
                                 <== NOT EXECUTED
      dd->block_count = dd->size / media_blocks_per_block;
           
40006ff8:	c4 27 60 28 	st  %g2, [ %i5 + 0x28 ]
                       <== NOT EXECUTED
  rtems_status_code sc = RTEMS_SUCCESSFUL;
                           
40006ffc:	b0 10 20 00 	clr  %i0
                                      <== NOT EXECUTED
      dd->media_blocks_per_block = media_blocks_per_block;
           
40007000:	c6 27 60 2c 	st  %g3, [ %i5 + 0x2c ]
                       <== NOT EXECUTED
      dd->block_to_media_block_shift = block_to_media_block_shift;
   
40007004:	c2 27 60 30 	st  %g1, [ %i5 + 0x30 ]
                       <== NOT EXECUTED
      rtems_bdbuf_do_purge_dev (dd);
                                 
40007008:	7f ff fa f3 	call  40005bd4 <rtems_bdbuf_do_purge_dev>
     <== NOT EXECUTED
4000700c:	f4 27 60 34 	st  %i2, [ %i5 + 0x34 ]
                       <== NOT EXECUTED
  _Mutex_Release( mutex );
                                           
40007010:	40 00 53 9e 	call  4001be88 <_Mutex_Release>
               <== NOT EXECUTED
40007014:	90 17 21 ac 	or  %i4, 0x1ac, %o0
                           <== NOT EXECUTED
}
                                                                    
40007018:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4000701c:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
    rtems_bdbuf_syncdev (dd);
                                        
40007020:	7f ff ff 93 	call  40006e6c <rtems_bdbuf_syncdev>
          <== NOT EXECUTED
40007024:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
  _Mutex_Acquire( mutex );
                                           
40007028:	10 bf ff b9 	b  40006f0c <rtems_bdbuf_set_block_size+0x14>
 <== NOT EXECUTED
4000702c:	39 10 02 36 	sethi  %hi(0x4008d800), %i4
                   <== NOT EXECUTED

                                                                     
===============================================================================
40006cec <rtems_bdbuf_sync>:
                                         
{
                                                                    
40006cec:	9d e3 bf a0 	save  %sp, -96, %sp
                           <== NOT EXECUTED
  if (bd == NULL)
                                                    
40006cf0:	80 a6 20 00 	cmp  %i0, 0
                                   <== NOT EXECUTED
40006cf4:	02 80 00 48 	be  40006e14 <rtems_bdbuf_sync+0x128>
         <== NOT EXECUTED
40006cf8:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  _Mutex_Acquire( mutex );
                                           
40006cfc:	39 10 02 36 	sethi  %hi(0x4008d800), %i4
                   <== NOT EXECUTED
40006d00:	40 00 54 46 	call  4001be18 <_Mutex_Acquire>
               <== NOT EXECUTED
40006d04:	90 17 21 ac 	or  %i4, 0x1ac, %o0	! 4008d9ac <bdbuf_cache+0x28>
<== NOT EXECUTED
  switch (bd->state)
                                                 
40006d08:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0
                       <== NOT EXECUTED
40006d0c:	80 a2 20 03 	cmp  %o0, 3
                                   <== NOT EXECUTED
40006d10:	0a 80 00 54 	bcs  40006e60 <rtems_bdbuf_sync+0x174>
        <== NOT EXECUTED
40006d14:	80 a2 20 05 	cmp  %o0, 5
                                   <== NOT EXECUTED
40006d18:	08 80 00 0b 	bleu  40006d44 <rtems_bdbuf_sync+0x58>
        <== NOT EXECUTED
40006d1c:	80 a2 20 06 	cmp  %o0, 6
                                   <== NOT EXECUTED
40006d20:	12 80 00 50 	bne  40006e60 <rtems_bdbuf_sync+0x174>
        <== NOT EXECUTED
40006d24:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
      rtems_bdbuf_discard_buffer_after_access (bd);
                  
40006d28:	7f ff fe 94 	call  40006778 <rtems_bdbuf_discard_buffer_after_access>
<== NOT EXECUTED
40006d2c:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
  _Mutex_Release( mutex );
                                           
40006d30:	90 17 21 ac 	or  %i4, 0x1ac, %o0
                           <== NOT EXECUTED
40006d34:	40 00 54 55 	call  4001be88 <_Mutex_Release>
               <== NOT EXECUTED
40006d38:	b0 10 20 00 	clr  %i0
                                      <== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
                                           
40006d3c:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40006d40:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
  bd->state = state;
                                                 
40006d44:	82 10 20 08 	mov  8, %g1
                                   <== NOT EXECUTED
  old_last = tail->previous;
                                         
40006d48:	3b 10 02 36 	sethi  %hi(0x4008d800), %i5
                   <== NOT EXECUTED
40006d4c:	c2 26 20 20 	st  %g1, [ %i0 + 0x20 ]
                       <== NOT EXECUTED
40006d50:	ba 17 61 84 	or  %i5, 0x184, %i5
                           <== NOT EXECUTED
40006d54:	c2 07 60 80 	ld  [ %i5 + 0x80 ], %g1
                       <== NOT EXECUTED
  the_node->next = tail;
                                             
40006d58:	84 07 60 7c 	add  %i5, 0x7c, %g2
                           <== NOT EXECUTED
40006d5c:	c4 26 00 00 	st  %g2, [ %i0 ]
                              <== NOT EXECUTED
  tail->previous = the_node;
                                         
40006d60:	f0 27 60 80 	st  %i0, [ %i5 + 0x80 ]
                       <== NOT EXECUTED
  old_last->next = the_node;
                                         
40006d64:	f0 20 40 00 	st  %i0, [ %g1 ]
                              <== NOT EXECUTED
  the_node->previous = old_last;
                                     
40006d68:	c2 26 20 04 	st  %g1, [ %i0 + 4 ]
                          <== NOT EXECUTED
  if (bd->waiters)
                                                   
40006d6c:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1
                       <== NOT EXECUTED
40006d70:	80 a0 60 00 	cmp  %g1, 0
                                   <== NOT EXECUTED
40006d74:	32 80 00 2a 	bne,a   40006e1c <rtems_bdbuf_sync+0x130>
     <== NOT EXECUTED
40006d78:	c2 07 60 84 	ld  [ %i5 + 0x84 ], %g1
                       <== NOT EXECUTED
  rtems_bdbuf_wake_swapper ();
                                       
40006d7c:	7f ff f6 cd 	call  400048b0 <rtems_bdbuf_wake_swapper>
     <== NOT EXECUTED
40006d80:	37 10 02 36 	sethi  %hi(0x4008d800), %i3
                   <== NOT EXECUTED
    switch (bd->state)
                                               
40006d84:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0
                       <== NOT EXECUTED
40006d88:	80 a2 20 01 	cmp  %o0, 1
                                   <== NOT EXECUTED
40006d8c:	0a 80 00 0e 	bcs  40006dc4 <rtems_bdbuf_sync+0xd8>
         <== NOT EXECUTED
40006d90:	b6 16 e2 20 	or  %i3, 0x220, %i3
                           <== NOT EXECUTED
40006d94:	80 a2 20 07 	cmp  %o0, 7
                                   <== NOT EXECUTED
40006d98:	08 80 00 0d 	bleu  40006dcc <rtems_bdbuf_sync+0xe0>
        <== NOT EXECUTED
40006d9c:	80 a2 20 0a 	cmp  %o0, 0xa
                                 <== NOT EXECUTED
40006da0:	18 80 00 09 	bgu  40006dc4 <rtems_bdbuf_sync+0xd8>
         <== NOT EXECUTED
40006da4:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
        rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
        
40006da8:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
40006dac:	7f ff f8 38 	call  40004e8c <rtems_bdbuf_wait>
             <== NOT EXECUTED
40006db0:	92 10 00 1b 	mov  %i3, %o1
                                 <== NOT EXECUTED
    switch (bd->state)
                                               
40006db4:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0
                       <== NOT EXECUTED
40006db8:	80 a2 20 01 	cmp  %o0, 1
                                   <== NOT EXECUTED
40006dbc:	1a bf ff f7 	bcc  40006d98 <rtems_bdbuf_sync+0xac>
         <== NOT EXECUTED
40006dc0:	80 a2 20 07 	cmp  %o0, 7
                                   <== NOT EXECUTED
        rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_9);

40006dc4:	7f ff f6 a2 	call  4000484c <rtems_bdbuf_fatal_with_state>
 <== NOT EXECUTED
40006dc8:	92 10 20 10 	mov  0x10, %o1
                                <== NOT EXECUTED
  if (bd->waiters == 0
                                               
40006dcc:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1
                       <== NOT EXECUTED
40006dd0:	80 a0 60 00 	cmp  %g1, 0
                                   <== NOT EXECUTED
40006dd4:	12 bf ff d7 	bne  40006d30 <rtems_bdbuf_sync+0x44>
         <== NOT EXECUTED
40006dd8:	82 02 3f ff 	add  %o0, -1, %g1
                             <== NOT EXECUTED
        && (bd->state == RTEMS_BDBUF_STATE_CACHED
                    
40006ddc:	80 a0 60 01 	cmp  %g1, 1
                                   <== NOT EXECUTED
40006de0:	38 bf ff d5 	bgu,a   40006d34 <rtems_bdbuf_sync+0x48>
      <== NOT EXECUTED
40006de4:	90 17 21 ac 	or  %i4, 0x1ac, %o0
                           <== NOT EXECUTED
    if (bd->state == RTEMS_BDBUF_STATE_EMPTY)
                        
40006de8:	80 a2 20 01 	cmp  %o0, 1
                                   <== NOT EXECUTED
40006dec:	02 80 00 12 	be  40006e34 <rtems_bdbuf_sync+0x148>
         <== NOT EXECUTED
40006df0:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  if (waiters->count > 0)
                                            
40006df4:	c2 07 60 b4 	ld  [ %i5 + 0xb4 ], %g1
                       <== NOT EXECUTED
40006df8:	80 a0 60 00 	cmp  %g1, 0
                                   <== NOT EXECUTED
40006dfc:	22 bf ff ce 	be,a   40006d34 <rtems_bdbuf_sync+0x48>
       <== NOT EXECUTED
40006e00:	90 17 21 ac 	or  %i4, 0x1ac, %o0
                           <== NOT EXECUTED
  _Condition_Broadcast( condition_variable );
                        
40006e04:	40 00 4c 8d 	call  4001a038 <_Condition_Broadcast>
         <== NOT EXECUTED
40006e08:	90 07 60 b8 	add  %i5, 0xb8, %o0
                           <== NOT EXECUTED
  _Mutex_Release( mutex );
                                           
40006e0c:	10 bf ff ca 	b  40006d34 <rtems_bdbuf_sync+0x48>
           <== NOT EXECUTED
40006e10:	90 17 21 ac 	or  %i4, 0x1ac, %o0
                           <== NOT EXECUTED
}
                                                                    
40006e14:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40006e18:	91 e8 20 09 	restore  %g0, 9, %o0
                          <== NOT EXECUTED
  if (waiters->count > 0)
                                            
40006e1c:	80 a0 60 00 	cmp  %g1, 0
                                   <== NOT EXECUTED
40006e20:	02 bf ff d7 	be  40006d7c <rtems_bdbuf_sync+0x90>
          <== NOT EXECUTED
40006e24:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  _Condition_Broadcast( condition_variable );
                        
40006e28:	40 00 4c 84 	call  4001a038 <_Condition_Broadcast>
         <== NOT EXECUTED
40006e2c:	90 07 60 88 	add  %i5, 0x88, %o0
                           <== NOT EXECUTED
40006e30:	30 bf ff d3 	b,a   40006d7c <rtems_bdbuf_sync+0x90>
        <== NOT EXECUTED
      rtems_bdbuf_remove_from_tree (bd);
                             
40006e34:	7f ff f8 67 	call  40004fd0 <rtems_bdbuf_remove_from_tree>
 <== NOT EXECUTED
40006e38:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
  the_node->previous    = after_node;
                                
40006e3c:	03 10 02 36 	sethi  %hi(0x4008d800), %g1
                   <== NOT EXECUTED
40006e40:	82 10 61 e4 	or  %g1, 0x1e4, %g1	! 4008d9e4 <bdbuf_cache+0x60>
<== NOT EXECUTED
40006e44:	c2 26 20 04 	st  %g1, [ %i0 + 4 ]
                          <== NOT EXECUTED
  bd->state = state;
                                                 
40006e48:	c0 26 20 20 	clr  [ %i0 + 0x20 ]
                           <== NOT EXECUTED
  before_node           = after_node->next;
                          
40006e4c:	c2 07 60 60 	ld  [ %i5 + 0x60 ], %g1
                       <== NOT EXECUTED
  after_node->next      = the_node;
                                  
40006e50:	f0 27 60 60 	st  %i0, [ %i5 + 0x60 ]
                       <== NOT EXECUTED
  the_node->next        = before_node;
                               
40006e54:	c2 26 00 00 	st  %g1, [ %i0 ]
                              <== NOT EXECUTED
  before_node->previous = the_node;
                                  
40006e58:	10 bf ff e7 	b  40006df4 <rtems_bdbuf_sync+0x108>
          <== NOT EXECUTED
40006e5c:	f0 20 60 04 	st  %i0, [ %g1 + 4 ]
                          <== NOT EXECUTED
      rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_5);

40006e60:	7f ff f6 7b 	call  4000484c <rtems_bdbuf_fatal_with_state>
 <== NOT EXECUTED
40006e64:	92 10 20 0c 	mov  0xc, %o1
                                 <== NOT EXECUTED
40006e68:	01 00 00 00 	nop 
                                          <== NOT EXECUTED

                                                                     
===============================================================================
40006e6c <rtems_bdbuf_syncdev>:
                                      
{
                                                                    
40006e6c:	9d e3 bf a0 	save  %sp, -96, %sp
                           <== NOT EXECUTED
  _Mutex_Acquire( mutex );
                                           
40006e70:	39 10 02 36 	sethi  %hi(0x4008d800), %i4
                   <== NOT EXECUTED
40006e74:	40 00 53 e9 	call  4001be18 <_Mutex_Acquire>
               <== NOT EXECUTED
40006e78:	90 17 21 c0 	or  %i4, 0x1c0, %o0	! 4008d9c0 <bdbuf_cache+0x3c>
<== NOT EXECUTED
40006e7c:	37 10 02 36 	sethi  %hi(0x4008d800), %i3
                   <== NOT EXECUTED
40006e80:	40 00 53 e6 	call  4001be18 <_Mutex_Acquire>
               <== NOT EXECUTED
40006e84:	90 16 e1 ac 	or  %i3, 0x1ac, %o0	! 4008d9ac <bdbuf_cache+0x28>
<== NOT EXECUTED
  bdbuf_cache.sync_active    = true;
                                 
40006e88:	82 10 20 01 	mov  1, %g1
                                   <== NOT EXECUTED
40006e8c:	3b 10 02 36 	sethi  %hi(0x4008d800), %i5
                   <== NOT EXECUTED
40006e90:	ba 17 61 84 	or  %i5, 0x184, %i5	! 4008d984 <bdbuf_cache>
  <== NOT EXECUTED
  bdbuf_cache.sync_requester = rtems_task_self ();
                   
40006e94:	40 00 4a d0 	call  400199d4 <rtems_task_self>
              <== NOT EXECUTED
40006e98:	c2 2f 60 50 	stb  %g1, [ %i5 + 0x50 ]
                      <== NOT EXECUTED
{
                                                                    
40006e9c:	82 10 00 18 	mov  %i0, %g1
                                 <== NOT EXECUTED
  bdbuf_cache.sync_requester = rtems_task_self ();
                   
40006ea0:	d0 27 60 54 	st  %o0, [ %i5 + 0x54 ]
                       <== NOT EXECUTED
}
                                                                    
40006ea4:	b0 10 20 00 	clr  %i0
                                      <== NOT EXECUTED
  rtems_bdbuf_wake_swapper ();
                                       
40006ea8:	7f ff f6 82 	call  400048b0 <rtems_bdbuf_wake_swapper>
     <== NOT EXECUTED
40006eac:	c2 27 60 58 	st  %g1, [ %i5 + 0x58 ]
                       <== NOT EXECUTED
  _Mutex_Release( mutex );
                                           
40006eb0:	40 00 53 f6 	call  4001be88 <_Mutex_Release>
               <== NOT EXECUTED
40006eb4:	90 16 e1 ac 	or  %i3, 0x1ac, %o0
                           <== NOT EXECUTED
  rtems_bdbuf_wait_for_transient_event ();
                           
40006eb8:	7f ff f6 70 	call  40004878 <rtems_bdbuf_wait_for_transient_event>
<== NOT EXECUTED
40006ebc:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
40006ec0:	40 00 53 f2 	call  4001be88 <_Mutex_Release>
               <== NOT EXECUTED
40006ec4:	90 17 21 c0 	or  %i4, 0x1c0, %o0
                           <== NOT EXECUTED
}
                                                                    
40006ec8:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40006ecc:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED

                                                                     
===============================================================================
4003bef8 <rtems_bdpart_create>:
                                      
  const rtems_bdpart_format *format,
                                 
  rtems_bdpart_partition *pt,
                                        
  const unsigned *dist,
                                              
  size_t count
                                                       
)
                                                                    
{
                                                                    
4003bef8:	9d e3 bf 98 	save  %sp, -104, %sp
                          <== NOT EXECUTED
  rtems_status_code sc = RTEMS_SUCCESSFUL;
                           
  bool dos_compatibility = format != NULL
                            
    && format->type == RTEMS_BDPART_FORMAT_MBR
                       
    && format->mbr.dos_compatibility;
                                
4003befc:	80 a6 60 00 	cmp  %i1, 0
                                   <== NOT EXECUTED
4003bf00:	22 80 00 07 	be,a   4003bf1c <rtems_bdpart_create+0x24>
    <== NOT EXECUTED
4003bf04:	c0 27 bf fc 	clr  [ %fp + -4 ]
                             <== NOT EXECUTED
    && format->type == RTEMS_BDPART_FORMAT_MBR
                       
4003bf08:	c2 06 40 00 	ld  [ %i1 ], %g1
                              <== NOT EXECUTED
4003bf0c:	80 a0 60 00 	cmp  %g1, 0
                                   <== NOT EXECUTED
4003bf10:	22 80 00 76 	be,a   4003c0e8 <rtems_bdpart_create+0x1f0>
   <== NOT EXECUTED
4003bf14:	c2 0e 60 08 	ldub  [ %i1 + 8 ], %g1
                        <== NOT EXECUTED
  rtems_blkdev_bnum disk_end = 0;
                                    
4003bf18:	c0 27 bf fc 	clr  [ %fp + -4 ]
                             <== NOT EXECUTED
4003bf1c:	a2 10 20 00 	clr  %l1
                                      <== NOT EXECUTED
  rtems_blkdev_bnum pos = 0;
                                         
  rtems_blkdev_bnum dist_sum = 0;
                                    
  rtems_blkdev_bnum record_space =
                                   
    dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;
          
4003bf20:	a0 10 20 01 	mov  1, %l0
                                   <== NOT EXECUTED
  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) {
                                                  
4003bf24:	80 a7 20 00 	cmp  %i4, 0
                                   <== NOT EXECUTED
4003bf28:	02 80 00 6e 	be  4003c0e0 <rtems_bdpart_create+0x1e8>
      <== NOT EXECUTED
4003bf2c:	90 10 20 00 	clr  %o0
                                      <== NOT EXECUTED
    /* Nothing to do */
                                              
    return RTEMS_SUCCESSFUL;
                                         
  }
                                                                  

                                                                     
  /* Check parameter */
                                              
  if (format == NULL || pt == NULL || dist == NULL) {
                
4003bf30:	80 a0 00 1a 	cmp  %g0, %i2
                                 <== NOT EXECUTED
4003bf34:	84 60 3f ff 	subx  %g0, -1, %g2
                            <== NOT EXECUTED
4003bf38:	80 a0 00 1b 	cmp  %g0, %i3
                                 <== NOT EXECUTED
4003bf3c:	82 60 3f ff 	subx  %g0, -1, %g1
                            <== NOT EXECUTED
4003bf40:	80 90 80 01 	orcc  %g2, %g1, %g0
                           <== NOT EXECUTED
4003bf44:	12 80 00 6f 	bne  4003c100 <rtems_bdpart_create+0x208>
     <== NOT EXECUTED
4003bf48:	80 a6 60 00 	cmp  %i1, 0
                                   <== NOT EXECUTED
4003bf4c:	02 80 00 6d 	be  4003c100 <rtems_bdpart_create+0x208>
      <== NOT EXECUTED
4003bf50:	96 07 bf fc 	add  %fp, -4, %o3
                             <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;
                                    
  }
                                                                  

                                                                     
  /* Get disk data */
                                                
  sc = rtems_bdpart_get_disk_data( disk_name, NULL, NULL, &disk_end);

4003bf54:	94 10 20 00 	clr  %o2
                                      <== NOT EXECUTED
4003bf58:	92 10 20 00 	clr  %o1
                                      <== NOT EXECUTED
4003bf5c:	40 00 01 ec 	call  4003c70c <rtems_bdpart_get_disk_data>
   <== NOT EXECUTED
4003bf60:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL) {
                                      
4003bf64:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
4003bf68:	12 80 00 5e 	bne  4003c0e0 <rtems_bdpart_create+0x1e8>
     <== NOT EXECUTED
4003bf6c:	01 00 00 00 	nop 
                                          <== NOT EXECUTED

                                                                     
  /* Get distribution sum and check for overflow */
                  
  for (i = 0; i < count; ++i) {
                                      
    unsigned prev_sum = dist_sum;
                                    

                                                                     
    dist_sum += dist [i];
                                            
4003bf70:	c2 06 c0 00 	ld  [ %i3 ], %g1
                              <== NOT EXECUTED

                                                                     
    if (dist_sum < prev_sum) {
                                       
      return RTEMS_INVALID_NUMBER;
                                   
    }
                                                                

                                                                     
    if (dist [i] == 0) {
                                             
4003bf74:	80 a0 60 00 	cmp  %g1, 0
                                   <== NOT EXECUTED
4003bf78:	12 80 00 0d 	bne  4003bfac <rtems_bdpart_create+0xb4>
      <== NOT EXECUTED
4003bf7c:	88 10 20 00 	clr  %g4
                                      <== NOT EXECUTED
      return RTEMS_INVALID_NUMBER;
                                   
4003bf80:	10 80 00 64 	b  4003c110 <rtems_bdpart_create+0x218>
       <== NOT EXECUTED
4003bf84:	90 10 20 0a 	mov  0xa, %o0
                                 <== NOT EXECUTED
    dist_sum += dist [i];
                                            
4003bf88:	c4 06 c0 02 	ld  [ %i3 + %g2 ], %g2
                        <== NOT EXECUTED
4003bf8c:	82 80 80 01 	addcc  %g2, %g1, %g1
                          <== NOT EXECUTED
4003bf90:	88 10 00 03 	mov  %g3, %g4
                                 <== NOT EXECUTED
4003bf94:	86 40 20 00 	addx  %g0, 0, %g3
                             <== NOT EXECUTED
    if (dist [i] == 0) {
                                             
4003bf98:	80 a0 e0 00 	cmp  %g3, 0
                                   <== NOT EXECUTED
4003bf9c:	12 80 00 5c 	bne  4003c10c <rtems_bdpart_create+0x214>
     <== NOT EXECUTED
4003bfa0:	80 a0 a0 00 	cmp  %g2, 0
                                   <== NOT EXECUTED
4003bfa4:	22 80 00 5b 	be,a   4003c110 <rtems_bdpart_create+0x218>
   <== NOT EXECUTED
4003bfa8:	90 10 20 0a 	mov  0xa, %o0
                                 <== NOT EXECUTED
  for (i = 0; i < count; ++i) {
                                      
4003bfac:	86 01 20 01 	add  %g4, 1, %g3
                              <== NOT EXECUTED
4003bfb0:	80 a7 00 03 	cmp  %i4, %g3
                                 <== NOT EXECUTED
4003bfb4:	12 bf ff f5 	bne  4003bf88 <rtems_bdpart_create+0x90>
      <== NOT EXECUTED
4003bfb8:	85 28 e0 02 	sll  %g3, 2, %g2
                              <== NOT EXECUTED
    }
                                                                
  }
                                                                  

                                                                     
  /* Check format */
                                                 
  if (format->type != RTEMS_BDPART_FORMAT_MBR) {
                     
4003bfbc:	c4 06 40 00 	ld  [ %i1 ], %g2
                              <== NOT EXECUTED
4003bfc0:	80 a0 a0 00 	cmp  %g2, 0
                                   <== NOT EXECUTED
4003bfc4:	12 80 00 55 	bne  4003c118 <rtems_bdpart_create+0x220>
     <== NOT EXECUTED
4003bfc8:	80 a4 60 00 	cmp  %l1, 0
                                   <== NOT EXECUTED
    return RTEMS_NOT_IMPLEMENTED;
                                    
  }
                                                                  

                                                                     
  /* Align end of disk on cylinder boundary if necessary */
          
  if (dos_compatibility) {
                                           
4003bfcc:	02 80 00 55 	be  4003c120 <rtems_bdpart_create+0x228>
      <== NOT EXECUTED
4003bfd0:	d8 07 bf fc 	ld  [ %fp + -4 ], %o4
                         <== NOT EXECUTED
    disk_end -= (disk_end % record_space);
                           
4003bfd4:	81 80 20 00 	wr  %g0, %y
                                   <== NOT EXECUTED
4003bfd8:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
4003bfdc:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
4003bfe0:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
4003bfe4:	84 73 00 10 	udiv  %o4, %l0, %g2
                           <== NOT EXECUTED

                                                                     
  /*
                                                                 
   * In case we need an extended partition and logical partitions we have to

   * account for the space of each EBR.
                              
   */
                                                                
  if (count > 4) {
                                                   
4003bfe8:	80 a0 e0 04 	cmp  %g3, 4
                                   <== NOT EXECUTED
4003bfec:	08 80 00 54 	bleu  4003c13c <rtems_bdpart_create+0x244>
    <== NOT EXECUTED
4003bff0:	98 58 80 10 	smul  %g2, %l0, %o4
                           <== NOT EXECUTED
    overhead += (count - 3) * record_space;
                          
4003bff4:	84 01 3f fe 	add  %g4, -2, %g2
                             <== NOT EXECUTED
4003bff8:	84 58 80 10 	smul  %g2, %l0, %g2
                           <== NOT EXECUTED
4003bffc:	b8 00 80 10 	add  %g2, %l0, %i4
                            <== NOT EXECUTED
  /*
                                                                 
   * Account space to align every partition on cylinder boundaries if

   * necessary.
                                                      
   */
                                                                
  if (dos_compatibility) {
                                           
    overhead += (count - 1) * record_space;
                          
4003c000:	84 5c 00 04 	smul  %l0, %g4, %g2
                           <== NOT EXECUTED
4003c004:	84 00 80 1c 	add  %g2, %i4, %g2
                            <== NOT EXECUTED
  }
                                                                  

                                                                     
  /* Check disk space */
                                             
  if ((overhead + count) > disk_end) {
                               
4003c008:	88 00 80 03 	add  %g2, %g3, %g4
                            <== NOT EXECUTED
4003c00c:	80 a1 00 0c 	cmp  %g4, %o4
                                 <== NOT EXECUTED
4003c010:	18 80 00 49 	bgu  4003c134 <rtems_bdpart_create+0x23c>
     <== NOT EXECUTED
4003c014:	84 23 00 02 	sub  %o4, %g2, %g2
                            <== NOT EXECUTED
4003c018:	9e 10 00 1a 	mov  %i2, %o7
                                 <== NOT EXECUTED
    return RTEMS_IO_ERROR;
                                           
  }
                                                                  

                                                                     
  /* Begin of first primary partition */
                             
  pos = record_space;
                                                
4003c01c:	b2 10 00 10 	mov  %l0, %i1
                                 <== NOT EXECUTED

                                                                     
  /* Space for partitions */
                                         
  free_space = disk_end - overhead;
                                  

                                                                     
  for (i = 0; i < count; ++i) {
                                      
4003c020:	b0 10 20 00 	clr  %i0
                                      <== NOT EXECUTED
    rtems_bdpart_partition *p = pt + i;
                              

                                                                     
    /* Partition size */
                                             
    rtems_blkdev_bnum s = free_space * dist [i];
                     
4003c024:	89 2e 20 02 	sll  %i0, 2, %g4
                              <== NOT EXECUTED
4003c028:	f8 06 c0 04 	ld  [ %i3 + %g4 ], %i4
                        <== NOT EXECUTED
4003c02c:	88 5f 00 02 	smul  %i4, %g2, %g4
                           <== NOT EXECUTED
    if (s < free_space || s < dist [i]) {
                            
4003c030:	80 a1 00 02 	cmp  %g4, %g2
                                 <== NOT EXECUTED
4003c034:	0a 80 00 36 	bcs  4003c10c <rtems_bdpart_create+0x214>
     <== NOT EXECUTED
4003c038:	80 a1 00 1c 	cmp  %g4, %i4
                                 <== NOT EXECUTED
4003c03c:	2a 80 00 35 	bcs,a   4003c110 <rtems_bdpart_create+0x218>
  <== NOT EXECUTED
4003c040:	90 10 20 0a 	mov  0xa, %o0
                                 <== NOT EXECUTED
      return RTEMS_INVALID_NUMBER;
                                   
    }
                                                                
    s /= dist_sum;
                                                   

                                                                     
    /* Ensure that the partition is not empty */
                     
    if (s == 0) {
                                                    
4003c044:	81 80 20 00 	wr  %g0, %y
                                   <== NOT EXECUTED
4003c048:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
4003c04c:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
4003c050:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
4003c054:	88 f1 00 01 	udivcc  %g4, %g1, %g4
                         <== NOT EXECUTED
4003c058:	22 80 00 02 	be,a   4003c060 <rtems_bdpart_create+0x168>
   <== NOT EXECUTED
4003c05c:	88 10 20 01 	mov  1, %g4
                                   <== NOT EXECUTED
      s = 1;
                                                         
    }
                                                                

                                                                     
    /* Align partition upwards */
                                    
    s += record_space - (s % record_space);
                          
4003c060:	81 80 20 00 	wr  %g0, %y
                                   <== NOT EXECUTED
4003c064:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
4003c068:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
4003c06c:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
4003c070:	b8 71 00 10 	udiv  %g4, %l0, %i4
                           <== NOT EXECUTED

                                                                     
    /* Reserve space for the EBR if necessary */
                     
    if (count > 4 && i > 2) {
                                        
4003c074:	9a 10 20 01 	mov  1, %o5
                                   <== NOT EXECUTED
    s += record_space - (s % record_space);
                          
4003c078:	88 5f 00 10 	smul  %i4, %l0, %g4
                           <== NOT EXECUTED
    if (count > 4 && i > 2) {
                                        
4003c07c:	80 a0 e0 04 	cmp  %g3, 4
                                   <== NOT EXECUTED
4003c080:	18 80 00 03 	bgu  4003c08c <rtems_bdpart_create+0x194>
     <== NOT EXECUTED
4003c084:	88 04 00 04 	add  %l0, %g4, %g4
                            <== NOT EXECUTED
4003c088:	9a 10 20 00 	clr  %o5
                                      <== NOT EXECUTED
4003c08c:	80 8b 60 ff 	btst  0xff, %o5
                               <== NOT EXECUTED
4003c090:	02 80 00 08 	be  4003c0b0 <rtems_bdpart_create+0x1b8>
      <== NOT EXECUTED
4003c094:	80 a6 20 02 	cmp  %i0, 2
                                   <== NOT EXECUTED
4003c098:	18 80 00 03 	bgu  4003c0a4 <rtems_bdpart_create+0x1ac>
     <== NOT EXECUTED
4003c09c:	b8 10 20 01 	mov  1, %i4
                                   <== NOT EXECUTED
4003c0a0:	b8 10 20 00 	clr  %i4
                                      <== NOT EXECUTED
4003c0a4:	80 8f 20 ff 	btst  0xff, %i4
                               <== NOT EXECUTED
4003c0a8:	32 80 00 02 	bne,a   4003c0b0 <rtems_bdpart_create+0x1b8>
  <== NOT EXECUTED
4003c0ac:	b2 06 40 10 	add  %i1, %l0, %i1
                            <== NOT EXECUTED
      pos += record_space;
                                           
    }
                                                                

                                                                     
    /* Partition begin and end */
                                    
    p->begin = pos;
                                                  
4003c0b0:	f2 23 c0 00 	st  %i1, [ %o7 ]
                              <== NOT EXECUTED
    pos += s;
                                                        
4003c0b4:	b2 06 40 04 	add  %i1, %g4, %i1
                            <== NOT EXECUTED
    p->end = pos;
                                                    
4003c0b8:	f2 23 e0 04 	st  %i1, [ %o7 + 4 ]
                          <== NOT EXECUTED
  for (i = 0; i < count; ++i) {
                                      
4003c0bc:	b0 06 20 01 	inc  %i0
                                      <== NOT EXECUTED
4003c0c0:	80 a6 00 03 	cmp  %i0, %g3
                                 <== NOT EXECUTED
4003c0c4:	12 bf ff d8 	bne  4003c024 <rtems_bdpart_create+0x12c>
     <== NOT EXECUTED
4003c0c8:	9e 03 e0 30 	add  %o7, 0x30, %o7
                           <== NOT EXECUTED
  }
                                                                  

                                                                     
  /* Expand the last partition to the disk end */
                    
  pt [count - 1].end = disk_end;
                                     
4003c0cc:	83 2e 20 01 	sll  %i0, 1, %g1
                              <== NOT EXECUTED
4003c0d0:	82 00 40 18 	add  %g1, %i0, %g1
                            <== NOT EXECUTED
4003c0d4:	83 28 60 04 	sll  %g1, 4, %g1
                              <== NOT EXECUTED
4003c0d8:	b4 06 80 01 	add  %i2, %g1, %i2
                            <== NOT EXECUTED
4003c0dc:	d8 26 bf d4 	st  %o4, [ %i2 + -44 ]
                        <== NOT EXECUTED

                                                                     
  return RTEMS_SUCCESSFUL;
                                           
}
                                                                    
4003c0e0:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4003c0e4:	91 e8 00 08 	restore  %g0, %o0, %o0
                        <== NOT EXECUTED
    && format->mbr.dos_compatibility;
                                
4003c0e8:	80 a0 60 00 	cmp  %g1, 0
                                   <== NOT EXECUTED
4003c0ec:	02 bf ff 8c 	be  4003bf1c <rtems_bdpart_create+0x24>
       <== NOT EXECUTED
4003c0f0:	c0 27 bf fc 	clr  [ %fp + -4 ]
                             <== NOT EXECUTED
4003c0f4:	a2 10 20 01 	mov  1, %l1
                                   <== NOT EXECUTED
    dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;
          
4003c0f8:	10 bf ff 8b 	b  4003bf24 <rtems_bdpart_create+0x2c>
        <== NOT EXECUTED
4003c0fc:	a0 10 20 3f 	mov  0x3f, %l0
                                <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;
                                    
4003c100:	90 10 20 09 	mov  9, %o0
                                   <== NOT EXECUTED
}
                                                                    
4003c104:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4003c108:	91 e8 00 08 	restore  %g0, %o0, %o0
                        <== NOT EXECUTED
      return RTEMS_INVALID_NUMBER;
                                   
4003c10c:	90 10 20 0a 	mov  0xa, %o0
                                 <== NOT EXECUTED
}
                                                                    
4003c110:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4003c114:	91 e8 00 08 	restore  %g0, %o0, %o0
                        <== NOT EXECUTED
    return RTEMS_NOT_IMPLEMENTED;
                                    
4003c118:	10 bf ff f2 	b  4003c0e0 <rtems_bdpart_create+0x1e8>
       <== NOT EXECUTED
4003c11c:	90 10 20 18 	mov  0x18, %o0
                                <== NOT EXECUTED
  if (count > 4) {
                                                   
4003c120:	80 a0 e0 04 	cmp  %g3, 4
                                   <== NOT EXECUTED
4003c124:	38 80 00 08 	bgu,a   4003c144 <rtems_bdpart_create+0x24c>
  <== NOT EXECUTED
4003c128:	84 01 3f fe 	add  %g4, -2, %g2
                             <== NOT EXECUTED
  overhead += record_space;
                                          
4003c12c:	10 bf ff b7 	b  4003c008 <rtems_bdpart_create+0x110>
       <== NOT EXECUTED
4003c130:	84 10 00 10 	mov  %l0, %g2
                                 <== NOT EXECUTED
    return RTEMS_IO_ERROR;
                                           
4003c134:	10 bf ff eb 	b  4003c0e0 <rtems_bdpart_create+0x1e8>
       <== NOT EXECUTED
4003c138:	90 10 20 1b 	mov  0x1b, %o0
                                <== NOT EXECUTED
  overhead += record_space;
                                          
4003c13c:	10 bf ff b1 	b  4003c000 <rtems_bdpart_create+0x108>
       <== NOT EXECUTED
4003c140:	b8 10 00 10 	mov  %l0, %i4
                                 <== NOT EXECUTED
    overhead += (count - 3) * record_space;
                          
4003c144:	84 58 80 10 	smul  %g2, %l0, %g2
                           <== NOT EXECUTED
4003c148:	10 bf ff b0 	b  4003c008 <rtems_bdpart_create+0x110>
       <== NOT EXECUTED
4003c14c:	84 00 80 10 	add  %g2, %l0, %g2
                            <== NOT EXECUTED

                                                                     
===============================================================================
4003c150 <rtems_bdpart_dump>:
                                        
{
                                                                    
  uuid_unparse_lower( type, str);
                                    
}
                                                                    

                                                                     
void rtems_bdpart_dump( const rtems_bdpart_partition *pt, size_t count)

{
                                                                    
4003c150:	9d e3 bf 60 	save  %sp, -160, %sp
                          <== NOT EXECUTED
  size_t i = 0;
                                                      

                                                                     
  printf(
                                                            
4003c154:	11 10 02 0a 	sethi  %hi(0x40082800), %o0
                   <== NOT EXECUTED
4003c158:	7f ff ff 0b 	call  4003bd84 <__wrap_puts>
                  <== NOT EXECUTED
4003c15c:	90 12 22 e8 	or  %o0, 0x2e8, %o0	! 40082ae8 <test_state_strings+0x54>
<== NOT EXECUTED
    "------------+------------+-----------------------------------------------------\n"

    " BEGIN      | LAST       | TYPE\n"
                              
    "------------+------------+-----------------------------------------------------\n"

  );
                                                                 

                                                                     
  for (i = 0; i < count; ++i) {
                                      
4003c160:	80 a6 60 00 	cmp  %i1, 0
                                   <== NOT EXECUTED
4003c164:	02 80 00 35 	be  4003c238 <rtems_bdpart_dump+0xe8>
         <== NOT EXECUTED
4003c168:	83 2e 60 01 	sll  %i1, 1, %g1
                              <== NOT EXECUTED
4003c16c:	b0 06 20 08 	add  %i0, 8, %i0
                              <== NOT EXECUTED
4003c170:	b2 00 40 19 	add  %g1, %i1, %i1
                            <== NOT EXECUTED
          break;
                                                     
        case RTEMS_BDPART_MBR_FAT_16_LBA:
                            
          type = "FAT 16 LBA";
                                       
          break;
                                                     
        case RTEMS_BDPART_MBR_FAT_32:
                                
          type = "FAT 32";
                                           
4003c174:	23 10 02 0a 	sethi  %hi(0x40082800), %l1
                   <== NOT EXECUTED
4003c178:	b3 2e 60 04 	sll  %i1, 4, %i1
                              <== NOT EXECUTED
          type = "FAT 16 LBA";
                                       
4003c17c:	21 10 02 0a 	sethi  %hi(0x40082800), %l0
                   <== NOT EXECUTED
          break;
                                                     
        case RTEMS_BDPART_MBR_FAT_32_LBA:
                            
          type = "FAT 32 LBA";
                                       
          break;
                                                     
        case RTEMS_BDPART_MBR_DATA:
                                  
          type = "DATA";
                                             
4003c180:	39 10 02 0a 	sethi  %hi(0x40082800), %i4
                   <== NOT EXECUTED
          type = "FAT 32 LBA";
                                       
4003c184:	03 10 02 0a 	sethi  %hi(0x40082800), %g1
                   <== NOT EXECUTED
          type = "FAT 12";
                                           
4003c188:	3b 10 02 0a 	sethi  %hi(0x40082800), %i5
                   <== NOT EXECUTED
4003c18c:	b2 06 40 18 	add  %i1, %i0, %i1
                            <== NOT EXECUTED
4003c190:	35 10 02 0b 	sethi  %hi(0x40082c00), %i2
                   <== NOT EXECUTED
          type = "FAT 32";
                                           
4003c194:	a2 14 62 d0 	or  %l1, 0x2d0, %l1
                           <== NOT EXECUTED
          type = "FAT 16 LBA";
                                       
4003c198:	a0 14 22 d8 	or  %l0, 0x2d8, %l0
                           <== NOT EXECUTED
          type = "DATA";
                                             
4003c19c:	b8 17 22 b8 	or  %i4, 0x2b8, %i4
                           <== NOT EXECUTED
          type = "FAT 32 LBA";
                                       
4003c1a0:	b6 10 62 c0 	or  %g1, 0x2c0, %i3
                           <== NOT EXECUTED
          type = "FAT 12";
                                           
4003c1a4:	ba 17 62 b0 	or  %i5, 0x2b0, %i5
                           <== NOT EXECUTED
    uint8_t type_mbr = 0;
                                            
4003c1a8:	c0 2f bf c7 	clrb  [ %fp + -57 ]
                           <== NOT EXECUTED
    if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {
   
4003c1ac:	92 07 bf c7 	add  %fp, -57, %o1
                            <== NOT EXECUTED
4003c1b0:	40 00 01 4b 	call  4003c6dc <rtems_bdpart_to_mbr_partition_type>
<== NOT EXECUTED
4003c1b4:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
4003c1b8:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
4003c1bc:	02 80 00 24 	be  4003c24c <rtems_bdpart_dump+0xfc>
         <== NOT EXECUTED
4003c1c0:	c2 0f bf c7 	ldub  [ %fp + -57 ], %g1
                      <== NOT EXECUTED
      switch (type_mbr) {
                                            
4003c1c4:	80 a0 60 0b 	cmp  %g1, 0xb
                                 <== NOT EXECUTED
4003c1c8:	02 80 00 13 	be  4003c214 <rtems_bdpart_dump+0xc4>
         <== NOT EXECUTED
4003c1cc:	96 10 00 11 	mov  %l1, %o3
                                 <== NOT EXECUTED
4003c1d0:	08 80 00 24 	bleu  4003c260 <rtems_bdpart_dump+0x110>
      <== NOT EXECUTED
4003c1d4:	80 a0 60 0e 	cmp  %g1, 0xe
                                 <== NOT EXECUTED
4003c1d8:	02 80 00 0f 	be  4003c214 <rtems_bdpart_dump+0xc4>
         <== NOT EXECUTED
4003c1dc:	96 10 00 10 	mov  %l0, %o3
                                 <== NOT EXECUTED
4003c1e0:	80 a0 60 da 	cmp  %g1, 0xda
                                <== NOT EXECUTED
4003c1e4:	02 80 00 0c 	be  4003c214 <rtems_bdpart_dump+0xc4>
         <== NOT EXECUTED
4003c1e8:	96 10 00 1c 	mov  %i4, %o3
                                 <== NOT EXECUTED
4003c1ec:	80 a0 60 0c 	cmp  %g1, 0xc
                                 <== NOT EXECUTED
4003c1f0:	02 80 00 09 	be  4003c214 <rtems_bdpart_dump+0xc4>
         <== NOT EXECUTED
4003c1f4:	96 10 00 1b 	mov  %i3, %o3
                                 <== NOT EXECUTED
          break;
                                                     
        default:
                                                     
          snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);

4003c1f8:	96 10 00 01 	mov  %g1, %o3
                                 <== NOT EXECUTED
4003c1fc:	92 10 20 34 	mov  0x34, %o1
                                <== NOT EXECUTED
4003c200:	15 10 02 0b 	sethi  %hi(0x40082c00), %o2
                   <== NOT EXECUTED
4003c204:	90 07 bf c8 	add  %fp, -56, %o0
                            <== NOT EXECUTED
4003c208:	40 00 9d 01 	call  4006360c <snprintf>
                     <== NOT EXECUTED
4003c20c:	94 12 a0 28 	or  %o2, 0x28, %o2
                            <== NOT EXECUTED
          type = type_buffer;
                                        
4003c210:	96 07 bf c8 	add  %fp, -56, %o3
                            <== NOT EXECUTED
    } else {
                                                         
      rtems_bdpart_type_to_string( p->type, type_buffer);
            
      type = type_buffer;
                                            
    }
                                                                

                                                                     
    printf(
                                                          
4003c214:	d4 06 3f fc 	ld  [ %i0 + -4 ], %o2
                         <== NOT EXECUTED
4003c218:	d2 06 3f f8 	ld  [ %i0 + -8 ], %o1
                         <== NOT EXECUTED
4003c21c:	94 02 bf ff 	add  %o2, -1, %o2
                             <== NOT EXECUTED
4003c220:	7f ff fe ca 	call  4003bd48 <__wrap_printf>
                <== NOT EXECUTED
4003c224:	90 16 a0 38 	or  %i2, 0x38, %o0
                            <== NOT EXECUTED
4003c228:	b0 06 20 30 	add  %i0, 0x30, %i0
                           <== NOT EXECUTED
  for (i = 0; i < count; ++i) {
                                      
4003c22c:	80 a6 00 19 	cmp  %i0, %i1
                                 <== NOT EXECUTED
4003c230:	32 bf ff df 	bne,a   4003c1ac <rtems_bdpart_dump+0x5c>
     <== NOT EXECUTED
4003c234:	c0 2f bf c7 	clrb  [ %fp + -57 ]
                           <== NOT EXECUTED
      p->end - 1U,
                                                   
      type
                                                           
    );
                                                               
  }
                                                                  

                                                                     
  puts( "------------+------------+-----------------------------------------------------");

4003c238:	11 10 02 0a 	sethi  %hi(0x40082800), %o0
                   <== NOT EXECUTED
4003c23c:	7f ff fe d2 	call  4003bd84 <__wrap_puts>
                  <== NOT EXECUTED
4003c240:	90 12 23 d8 	or  %o0, 0x3d8, %o0	! 40082bd8 <test_state_strings+0x144>
<== NOT EXECUTED
}
                                                                    
4003c244:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4003c248:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
  uuid_unparse_lower( type, str);
                                    
4003c24c:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
4003c250:	40 00 6f 7f 	call  4005804c <uuid_unparse_lower>
           <== NOT EXECUTED
4003c254:	92 07 bf c8 	add  %fp, -56, %o1
                            <== NOT EXECUTED
      type = type_buffer;
                                            
4003c258:	10 bf ff ef 	b  4003c214 <rtems_bdpart_dump+0xc4>
          <== NOT EXECUTED
4003c25c:	96 07 bf c8 	add  %fp, -56, %o3
                            <== NOT EXECUTED
      switch (type_mbr) {
                                            
4003c260:	80 a0 60 01 	cmp  %g1, 1
                                   <== NOT EXECUTED
4003c264:	02 bf ff ec 	be  4003c214 <rtems_bdpart_dump+0xc4>
         <== NOT EXECUTED
4003c268:	96 10 00 1d 	mov  %i5, %o3
                                 <== NOT EXECUTED
4003c26c:	80 a0 60 04 	cmp  %g1, 4
                                   <== NOT EXECUTED
4003c270:	12 bf ff e2 	bne  4003c1f8 <rtems_bdpart_dump+0xa8>
        <== NOT EXECUTED
4003c274:	17 10 02 0a 	sethi  %hi(0x40082800), %o3
                   <== NOT EXECUTED
          type = "FAT 16";
                                           
4003c278:	10 bf ff e7 	b  4003c214 <rtems_bdpart_dump+0xc4>
          <== NOT EXECUTED
4003c27c:	96 12 e2 a8 	or  %o3, 0x2a8, %o3	! 40082aa8 <test_state_strings+0x14>
<== NOT EXECUTED

                                                                     
===============================================================================
4003c70c <rtems_bdpart_get_disk_data>:
                               
{
                                                                    
4003c70c:	9d e3 bf 98 	save  %sp, -104, %sp
                          <== NOT EXECUTED
  fd = open( disk_name, O_RDWR);
                                     
4003c710:	92 10 20 02 	mov  2, %o1
                                   <== NOT EXECUTED
4003c714:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
  rtems_disk_device *dd = NULL;
                                      
4003c718:	c0 27 bf fc 	clr  [ %fp + -4 ]
                             <== NOT EXECUTED
  fd = open( disk_name, O_RDWR);
                                     
4003c71c:	7f ff 3f 00 	call  4000c31c <open>
                         <== NOT EXECUTED
4003c720:	b0 10 20 03 	mov  3, %i0
                                   <== NOT EXECUTED
  if (fd < 0) {
                                                      
4003c724:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
4003c728:	06 80 00 0b 	bl  4003c754 <rtems_bdpart_get_disk_data+0x48>
<== NOT EXECUTED
4003c72c:	ba 10 00 08 	mov  %o0, %i5
                                 <== NOT EXECUTED
  return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
                  
4003c730:	94 07 bf fc 	add  %fp, -4, %o2
                             <== NOT EXECUTED
4003c734:	13 10 01 10 	sethi  %hi(0x40044000), %o1
                   <== NOT EXECUTED
4003c738:	7f ff 3c 4f 	call  4000b874 <ioctl>
                        <== NOT EXECUTED
4003c73c:	92 12 62 09 	or  %o1, 0x209, %o1	! 40044209 <rtems_rate_monotonic_report_statistics_with_plugin+0x125>
<== NOT EXECUTED
  if (rv != 0) {
                                                     
4003c740:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
4003c744:	02 80 00 06 	be  4003c75c <rtems_bdpart_get_disk_data+0x50>
<== NOT EXECUTED
4003c748:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1
                         <== NOT EXECUTED
    close( fd);
                                                      
4003c74c:	7f ff 3b 08 	call  4000b36c <close>
                        <== NOT EXECUTED
4003c750:	90 10 00 1d 	mov  %i5, %o0
                                 <== NOT EXECUTED
}
                                                                    
4003c754:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4003c758:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
  *disk_end = dd->size;
                                              
4003c75c:	c4 00 60 1c 	ld  [ %g1 + 0x1c ], %g2
                       <== NOT EXECUTED
  disk_begin = dd->start;
                                            
4003c760:	c8 00 60 18 	ld  [ %g1 + 0x18 ], %g4
                       <== NOT EXECUTED
  *disk_end = dd->size;
                                              
4003c764:	c4 26 c0 00 	st  %g2, [ %i3 ]
                              <== NOT EXECUTED
  if (block_size < RTEMS_BDPART_BLOCK_SIZE) {
                        
4003c768:	c6 00 60 24 	ld  [ %g1 + 0x24 ], %g3
                       <== NOT EXECUTED
4003c76c:	80 a0 e1 ff 	cmp  %g3, 0x1ff
                               <== NOT EXECUTED
4003c770:	18 80 00 0b 	bgu  4003c79c <rtems_bdpart_get_disk_data+0x90>
<== NOT EXECUTED
4003c774:	84 10 20 01 	mov  1, %g2
                                   <== NOT EXECUTED
  if (disk_begin != 0) {
                                             
4003c778:	80 88 a0 ff 	btst  0xff, %g2
                               <== NOT EXECUTED
4003c77c:	12 80 00 04 	bne  4003c78c <rtems_bdpart_get_disk_data+0x80>
<== NOT EXECUTED
4003c780:	80 a1 20 00 	cmp  %g4, 0
                                   <== NOT EXECUTED
4003c784:	02 80 00 08 	be  4003c7a4 <rtems_bdpart_get_disk_data+0x98>
<== NOT EXECUTED
4003c788:	80 a6 60 00 	cmp  %i1, 0
                                   <== NOT EXECUTED
    sc = RTEMS_IO_ERROR;
                                             
4003c78c:	b0 10 20 1b 	mov  0x1b, %i0
                                <== NOT EXECUTED
    close( fd);
                                                      
4003c790:	7f ff 3a f7 	call  4000b36c <close>
                        <== NOT EXECUTED
4003c794:	90 10 00 1d 	mov  %i5, %o0
                                 <== NOT EXECUTED
4003c798:	30 bf ff ef 	b,a   4003c754 <rtems_bdpart_get_disk_data+0x48>
<== NOT EXECUTED
  if (block_size < RTEMS_BDPART_BLOCK_SIZE) {
                        
4003c79c:	10 bf ff f7 	b  4003c778 <rtems_bdpart_get_disk_data+0x6c>
 <== NOT EXECUTED
4003c7a0:	84 10 20 00 	clr  %g2
                                      <== NOT EXECUTED
  if (sc == RTEMS_SUCCESSFUL && fd_ptr != NULL && dd_ptr != NULL) {
  
4003c7a4:	02 80 00 08 	be  4003c7c4 <rtems_bdpart_get_disk_data+0xb8>
<== NOT EXECUTED
4003c7a8:	80 a6 a0 00 	cmp  %i2, 0
                                   <== NOT EXECUTED
4003c7ac:	02 bf ff e8 	be  4003c74c <rtems_bdpart_get_disk_data+0x40>
<== NOT EXECUTED
4003c7b0:	b0 10 20 00 	clr  %i0
                                      <== NOT EXECUTED
    *fd_ptr = fd;
                                                    
4003c7b4:	fa 26 40 00 	st  %i5, [ %i1 ]
                              <== NOT EXECUTED
    *dd_ptr = dd;
                                                    
4003c7b8:	c2 26 80 00 	st  %g1, [ %i2 ]
                              <== NOT EXECUTED
4003c7bc:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4003c7c0:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
  rtems_status_code sc = RTEMS_SUCCESSFUL;
                           
4003c7c4:	10 bf ff e2 	b  4003c74c <rtems_bdpart_get_disk_data+0x40>
 <== NOT EXECUTED
4003c7c8:	b0 10 20 00 	clr  %i0
                                      <== NOT EXECUTED

                                                                     
===============================================================================
4003c280 <rtems_bdpart_mount>:
                                       
  const char *disk_name,
                                             
  const rtems_bdpart_partition *pt RTEMS_UNUSED,
                     
  size_t count,
                                                      
  const char *mount_base
                                             
)
                                                                    
{
                                                                    
4003c280:	9d e3 bf a0 	save  %sp, -96, %sp
                           <== NOT EXECUTED
  rtems_status_code esc = RTEMS_SUCCESSFUL;
                          
  const char *disk_file_name = strrchr( disk_name, '/');
             
4003c284:	92 10 20 2f 	mov  0x2f, %o1
                                <== NOT EXECUTED
4003c288:	40 00 a6 32 	call  40065b50 <strrchr>
                      <== NOT EXECUTED
4003c28c:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
4003c290:	ba 10 00 08 	mov  %o0, %i5
                                 <== NOT EXECUTED
  char *logical_disk_name = NULL;
                                    
  char *logical_disk_marker = NULL;
                                  
  char *mount_point = NULL;
                                          
  char *mount_marker = NULL;
                                         
  size_t disk_file_name_size = 0;
                                    
  size_t disk_name_size = strlen( disk_name);
                        
4003c294:	40 00 a1 1b 	call  40064700 <strlen>
                       <== NOT EXECUTED
4003c298:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
4003c29c:	b8 10 00 08 	mov  %o0, %i4
                                 <== NOT EXECUTED
  size_t mount_base_size = strlen( mount_base);
                      
4003c2a0:	40 00 a1 18 	call  40064700 <strlen>
                       <== NOT EXECUTED
4003c2a4:	90 10 00 1b 	mov  %i3, %o0
                                 <== NOT EXECUTED
  size_t i = 0;
                                                      

                                                                     
  /* Create logical disk name base */
                                
  logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);

  if (logical_disk_name == NULL) {
                                   
    return RTEMS_NO_MEMORY;
                                          
4003c2a8:	a2 10 20 1a 	mov  0x1a, %l1
                                <== NOT EXECUTED
  size_t mount_base_size = strlen( mount_base);
                      
4003c2ac:	a4 10 00 08 	mov  %o0, %l2
                                 <== NOT EXECUTED
  logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);

4003c2b0:	7f ff 3e b7 	call  4000bd8c <malloc>
                       <== NOT EXECUTED
4003c2b4:	90 07 20 04 	add  %i4, 4, %o0
                              <== NOT EXECUTED
  if (logical_disk_name == NULL) {
                                   
4003c2b8:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
4003c2bc:	02 80 00 4f 	be  4003c3f8 <rtems_bdpart_mount+0x178>
       <== NOT EXECUTED
4003c2c0:	a0 10 00 08 	mov  %o0, %l0
                                 <== NOT EXECUTED
  }
                                                                  
  strncpy( logical_disk_name, disk_name, disk_name_size);
            
4003c2c4:	94 10 00 1c 	mov  %i4, %o2
                                 <== NOT EXECUTED
4003c2c8:	40 00 a1 b8 	call  400649a8 <strncpy>
                      <== NOT EXECUTED
4003c2cc:	92 10 00 18 	mov  %i0, %o1
                                 <== NOT EXECUTED

                                                                     
  /* Get disk file name */
                                           
  if (disk_file_name != NULL) {
                                      
4003c2d0:	80 a7 60 00 	cmp  %i5, 0
                                   <== NOT EXECUTED
4003c2d4:	02 80 00 06 	be  4003c2ec <rtems_bdpart_mount+0x6c>
        <== NOT EXECUTED
4003c2d8:	a6 10 00 1c 	mov  %i4, %l3
                                 <== NOT EXECUTED
    disk_file_name += 1;
                                             
4003c2dc:	b0 07 60 01 	add  %i5, 1, %i0
                              <== NOT EXECUTED
    disk_file_name_size = strlen( disk_file_name);
                   
4003c2e0:	40 00 a1 08 	call  40064700 <strlen>
                       <== NOT EXECUTED
4003c2e4:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
4003c2e8:	a6 10 00 08 	mov  %o0, %l3
                                 <== NOT EXECUTED
    disk_file_name = disk_name;
                                      
    disk_file_name_size = disk_name_size;
                            
  }
                                                                  

                                                                     
  /* Create mount point base */
                                      
  mount_point = malloc( mount_base_size + 1 + disk_file_name_size + RTEMS_BDPART_NUMBER_SIZE);

4003c2ec:	ba 04 c0 12 	add  %l3, %l2, %i5
                            <== NOT EXECUTED
  if (mount_point == NULL) {
                                         
    esc = RTEMS_NO_MEMORY;
                                           
4003c2f0:	a2 10 20 1a 	mov  0x1a, %l1
                                <== NOT EXECUTED
  mount_point = malloc( mount_base_size + 1 + disk_file_name_size + RTEMS_BDPART_NUMBER_SIZE);

4003c2f4:	7f ff 3e a6 	call  4000bd8c <malloc>
                       <== NOT EXECUTED
4003c2f8:	90 07 60 05 	add  %i5, 5, %o0
                              <== NOT EXECUTED
  if (mount_point == NULL) {
                                         
4003c2fc:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
4003c300:	02 80 00 3a 	be  4003c3e8 <rtems_bdpart_mount+0x168>
       <== NOT EXECUTED
4003c304:	b2 10 00 08 	mov  %o0, %i1
                                 <== NOT EXECUTED
    goto cleanup;
                                                    
  }
                                                                  
  strncpy( mount_point, mount_base, mount_base_size);
                
4003c308:	92 10 00 1b 	mov  %i3, %o1
                                 <== NOT EXECUTED
4003c30c:	40 00 a1 a7 	call  400649a8 <strncpy>
                      <== NOT EXECUTED
4003c310:	94 10 00 12 	mov  %l2, %o2
                                 <== NOT EXECUTED
  mount_point [mount_base_size] = '/';
                               
4003c314:	82 10 20 2f 	mov  0x2f, %g1
                                <== NOT EXECUTED
4003c318:	c2 2e 40 12 	stb  %g1, [ %i1 + %l2 ]
                       <== NOT EXECUTED
  strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);

4003c31c:	94 10 00 13 	mov  %l3, %o2
                                 <== NOT EXECUTED
4003c320:	90 04 a0 01 	add  %l2, 1, %o0
                              <== NOT EXECUTED
4003c324:	92 10 00 18 	mov  %i0, %o1
                                 <== NOT EXECUTED
4003c328:	40 00 a1 a0 	call  400649a8 <strncpy>
                      <== NOT EXECUTED
4003c32c:	90 06 40 08 	add  %i1, %o0, %o0
                            <== NOT EXECUTED

                                                                     
  /* Markers */
                                                      
  logical_disk_marker = logical_disk_name + disk_name_size;
          
  mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;

4003c330:	b6 07 60 01 	add  %i5, 1, %i3
                              <== NOT EXECUTED
  logical_disk_marker = logical_disk_name + disk_name_size;
          
4003c334:	b8 04 00 1c 	add  %l0, %i4, %i4
                            <== NOT EXECUTED

                                                                     
  /* Mount supported file systems for each partition */
              
  for (i = 0; i < count; ++i) {
                                      
4003c338:	ba 10 20 00 	clr  %i5
                                      <== NOT EXECUTED
4003c33c:	80 a6 a0 00 	cmp  %i2, 0
                                   <== NOT EXECUTED
4003c340:	02 80 00 29 	be  4003c3e4 <rtems_bdpart_mount+0x164>
       <== NOT EXECUTED
4003c344:	b6 06 40 1b 	add  %i1, %i3, %i3
                            <== NOT EXECUTED
    /* Create logical disk name */
                                   
    int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);

4003c348:	31 10 02 12 	sethi  %hi(0x40084800), %i0
                   <== NOT EXECUTED
      esc = RTEMS_IO_ERROR;
                                          
      goto cleanup;
                                                  
    }
                                                                

                                                                     
    /* Mount */
                                                      
    rv = mount(
                                                      
4003c34c:	23 10 02 0b 	sethi  %hi(0x40082c00), %l1
                   <== NOT EXECUTED
    int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);

4003c350:	b0 16 20 b0 	or  %i0, 0xb0, %i0
                            <== NOT EXECUTED
    rv = mount(
                                                      
4003c354:	10 80 00 04 	b  4003c364 <rtems_bdpart_mount+0xe4>
         <== NOT EXECUTED
4003c358:	a2 14 60 50 	or  %l1, 0x50, %l1
                            <== NOT EXECUTED
  for (i = 0; i < count; ++i) {
                                      
4003c35c:	22 80 00 23 	be,a   4003c3e8 <rtems_bdpart_mount+0x168>
    <== NOT EXECUTED
4003c360:	a2 10 20 00 	clr  %l1
                                      <== NOT EXECUTED
    int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);

4003c364:	94 10 00 18 	mov  %i0, %o2
                                 <== NOT EXECUTED
4003c368:	92 10 20 04 	mov  4, %o1
                                   <== NOT EXECUTED
4003c36c:	ba 07 60 01 	inc  %i5
                                      <== NOT EXECUTED
4003c370:	90 10 00 1c 	mov  %i4, %o0
                                 <== NOT EXECUTED
4003c374:	40 00 9c a6 	call  4006360c <snprintf>
                     <== NOT EXECUTED
4003c378:	96 10 00 1d 	mov  %i5, %o3
                                 <== NOT EXECUTED
    strncpy( mount_marker, logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE);

4003c37c:	94 10 20 04 	mov  4, %o2
                                   <== NOT EXECUTED
    if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
                            
4003c380:	80 a2 20 03 	cmp  %o0, 3
                                   <== NOT EXECUTED
    strncpy( mount_marker, logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE);

4003c384:	92 10 00 1c 	mov  %i4, %o1
                                 <== NOT EXECUTED
    if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
                            
4003c388:	14 80 00 1e 	bg  4003c400 <rtems_bdpart_mount+0x180>
       <== NOT EXECUTED
4003c38c:	90 10 00 1b 	mov  %i3, %o0
                                 <== NOT EXECUTED
    strncpy( mount_marker, logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE);

4003c390:	40 00 a1 86 	call  400649a8 <strncpy>
                      <== NOT EXECUTED
4003c394:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
    rv = rtems_mkdir( mount_point, S_IRWXU | S_IRWXG | S_IRWXO);
     
4003c398:	92 10 21 ff 	mov  0x1ff, %o1	! 1ff <SPARC_THREAD_CONTROL_FP_CONTEXT_OFFSET+0xaf>
<== NOT EXECUTED
4003c39c:	7f ff 41 85 	call  4000c9b0 <rtems_mkdir>
                  <== NOT EXECUTED
4003c3a0:	90 10 00 19 	mov  %i1, %o0
                                 <== NOT EXECUTED
    if (rv != 0) {
                                                   
4003c3a4:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
4003c3a8:	12 80 00 18 	bne  4003c408 <rtems_bdpart_mount+0x188>
      <== NOT EXECUTED
4003c3ac:	98 10 20 00 	clr  %o4
                                      <== NOT EXECUTED
    rv = mount(
                                                      
4003c3b0:	96 10 20 00 	clr  %o3
                                      <== NOT EXECUTED
4003c3b4:	94 10 00 11 	mov  %l1, %o2
                                 <== NOT EXECUTED
4003c3b8:	92 10 00 19 	mov  %i1, %o1
                                 <== NOT EXECUTED
4003c3bc:	7f ff 3e d0 	call  4000befc <mount>
                        <== NOT EXECUTED
4003c3c0:	90 10 00 10 	mov  %l0, %o0
                                 <== NOT EXECUTED
      mount_point,
                                                   
      "msdos",
                                                       
      0,
                                                             
      NULL
                                                           
    );
                                                               
    if (rv != 0) {
                                                   
4003c3c4:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
4003c3c8:	02 bf ff e5 	be  4003c35c <rtems_bdpart_mount+0xdc>
        <== NOT EXECUTED
4003c3cc:	80 a7 40 1a 	cmp  %i5, %i2
                                 <== NOT EXECUTED
      rmdir( mount_point);
                                           
4003c3d0:	40 00 1b 84 	call  400431e0 <rmdir>
                        <== NOT EXECUTED
4003c3d4:	90 10 00 19 	mov  %i1, %o0
                                 <== NOT EXECUTED
  for (i = 0; i < count; ++i) {
                                      
4003c3d8:	80 a7 40 1a 	cmp  %i5, %i2
                                 <== NOT EXECUTED
4003c3dc:	12 bf ff e3 	bne  4003c368 <rtems_bdpart_mount+0xe8>
       <== NOT EXECUTED
4003c3e0:	94 10 00 18 	mov  %i0, %o2
                                 <== NOT EXECUTED
  rtems_status_code esc = RTEMS_SUCCESSFUL;
                          
4003c3e4:	a2 10 20 00 	clr  %l1
                                      <== NOT EXECUTED
    }
                                                                
  }
                                                                  

                                                                     
cleanup:
                                                             

                                                                     
  free( logical_disk_name);
                                          
4003c3e8:	7f ff 3c a6 	call  4000b680 <free>
                         <== NOT EXECUTED
4003c3ec:	90 10 00 10 	mov  %l0, %o0
                                 <== NOT EXECUTED
  free( mount_point);
                                                
4003c3f0:	7f ff 3c a4 	call  4000b680 <free>
                         <== NOT EXECUTED
4003c3f4:	90 10 00 19 	mov  %i1, %o0
                                 <== NOT EXECUTED

                                                                     
  return esc;
                                                        
}
                                                                    
4003c3f8:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4003c3fc:	91 e8 00 11 	restore  %g0, %l1, %o0
                        <== NOT EXECUTED
      esc = RTEMS_INVALID_NAME;
                                      
4003c400:	10 bf ff fa 	b  4003c3e8 <rtems_bdpart_mount+0x168>
        <== NOT EXECUTED
4003c404:	a2 10 20 03 	mov  3, %l1
                                   <== NOT EXECUTED
      esc = RTEMS_IO_ERROR;
                                          
4003c408:	10 bf ff f8 	b  4003c3e8 <rtems_bdpart_mount+0x168>
        <== NOT EXECUTED
4003c40c:	a2 10 20 1b 	mov  0x1b, %l1
                                <== NOT EXECUTED

                                                                     
===============================================================================
4003c7cc <rtems_bdpart_read>:
                                        
  const char *disk_name,
                                             
  rtems_bdpart_format *format,
                                       
  rtems_bdpart_partition *pt,
                                        
  size_t *count
                                                      
)
                                                                    
{
                                                                    
4003c7cc:	9d e3 bf 88 	save  %sp, -120, %sp
                          <== NOT EXECUTED
  rtems_status_code sc = RTEMS_SUCCESSFUL;
                           
  rtems_status_code esc = RTEMS_SUCCESSFUL;
                          
  rtems_bdbuf_buffer *block = NULL;
                                  
  rtems_bdpart_partition *p = pt - 1;
                                
4003c7d0:	82 06 bf d0 	add  %i2, -48, %g1
                            <== NOT EXECUTED
  rtems_bdbuf_buffer *block = NULL;
                                  
4003c7d4:	c0 27 bf e8 	clr  [ %fp + -24 ]
                            <== NOT EXECUTED
  const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);

4003c7d8:	80 a6 e0 00 	cmp  %i3, 0
                                   <== NOT EXECUTED
4003c7dc:	02 80 00 17 	be  4003c838 <rtems_bdpart_read+0x6c>
         <== NOT EXECUTED
4003c7e0:	c2 27 bf ec 	st  %g1, [ %fp + -20 ]
                        <== NOT EXECUTED
  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;
                                                       
4003c7e4:	82 10 3f ff 	mov  -1, %g1
                                  <== NOT EXECUTED
  rtems_blkdev_bnum ep_begin = 0; /* Extended partition begin */
     
4003c7e8:	c0 27 bf f0 	clr  [ %fp + -16 ]
                            <== NOT EXECUTED
  rtems_disk_device *dd = NULL;
                                      

                                                                     
  /* Check parameter */
                                              
  if (format == NULL || pt == NULL || count == NULL) {
               
4003c7ec:	80 a6 60 00 	cmp  %i1, 0
                                   <== NOT EXECUTED
  rtems_blkdev_bnum disk_end = 0;
                                    
4003c7f0:	c0 27 bf f4 	clr  [ %fp + -12 ]
                            <== NOT EXECUTED
  int fd = -1;
                                                       
4003c7f4:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]
                         <== NOT EXECUTED
  rtems_disk_device *dd = NULL;
                                      
4003c7f8:	c0 27 bf fc 	clr  [ %fp + -4 ]
                             <== NOT EXECUTED
  if (format == NULL || pt == NULL || count == NULL) {
               
4003c7fc:	02 80 00 0f 	be  4003c838 <rtems_bdpart_read+0x6c>
         <== NOT EXECUTED
4003c800:	fa 06 c0 00 	ld  [ %i3 ], %i5
                              <== NOT EXECUTED
4003c804:	80 a6 a0 00 	cmp  %i2, 0
                                   <== NOT EXECUTED
4003c808:	02 80 00 0c 	be  4003c838 <rtems_bdpart_read+0x6c>
         <== NOT EXECUTED
4003c80c:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;
                                    
  }
                                                                  

                                                                     
  /* Set count to a save value */
                                    
  *count = 0;
                                                        
4003c810:	c0 26 c0 00 	clr  [ %i3 ]
                                  <== NOT EXECUTED

                                                                     
  /* Get disk data */
                                                
  sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
  
4003c814:	96 07 bf f4 	add  %fp, -12, %o3
                            <== NOT EXECUTED
4003c818:	94 07 bf fc 	add  %fp, -4, %o2
                             <== NOT EXECUTED
4003c81c:	7f ff ff bc 	call  4003c70c <rtems_bdpart_get_disk_data>
   <== NOT EXECUTED
4003c820:	92 07 bf f8 	add  %fp, -8, %o1
                             <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL) {
                                      
4003c824:	b0 92 20 00 	orcc  %o0, 0, %i0
                             <== NOT EXECUTED
4003c828:	02 80 00 06 	be  4003c840 <rtems_bdpart_read+0x74>
         <== NOT EXECUTED
4003c82c:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0
                         <== NOT EXECUTED
  if (block != NULL) {
                                               
    rtems_bdbuf_release( block);
                                     
  }
                                                                  

                                                                     
  return esc;
                                                        
}
                                                                    
4003c830:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4003c834:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;
                                    
4003c838:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4003c83c:	91 e8 20 09 	restore  %g0, 9, %o0
                          <== NOT EXECUTED
  sc = rtems_bdpart_read_record( dd, 0, &block);
                     
4003c840:	92 10 20 00 	clr  %o1
                                      <== NOT EXECUTED
4003c844:	7f ff ff 7d 	call  4003c638 <rtems_bdpart_read_record>
     <== NOT EXECUTED
4003c848:	94 07 bf e8 	add  %fp, -24, %o2
                            <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL) {
                                      
4003c84c:	b0 92 20 00 	orcc  %o0, 0, %i0
                             <== NOT EXECUTED
4003c850:	02 80 00 10 	be  4003c890 <rtems_bdpart_read+0xc4>
         <== NOT EXECUTED
4003c854:	c2 07 bf e8 	ld  [ %fp + -24 ], %g1
                        <== NOT EXECUTED
  if (fd >= 0) {
                                                     
4003c858:	d0 07 bf f8 	ld  [ %fp + -8 ], %o0
                         <== NOT EXECUTED
4003c85c:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
4003c860:	26 80 00 05 	bl,a   4003c874 <rtems_bdpart_read+0xa8>
      <== NOT EXECUTED
4003c864:	d0 07 bf e8 	ld  [ %fp + -24 ], %o0
                        <== NOT EXECUTED
    close( fd);
                                                      
4003c868:	7f ff 3a c1 	call  4000b36c <close>
                        <== NOT EXECUTED
4003c86c:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  if (block != NULL) {
                                               
4003c870:	d0 07 bf e8 	ld  [ %fp + -24 ], %o0
                        <== NOT EXECUTED
4003c874:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
4003c878:	02 80 00 04 	be  4003c888 <rtems_bdpart_read+0xbc>
         <== NOT EXECUTED
4003c87c:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
    rtems_bdbuf_release( block);
                                     
4003c880:	7f ff 28 b3 	call  40006b4c <rtems_bdbuf_release>
          <== NOT EXECUTED
4003c884:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
}
                                                                    
4003c888:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4003c88c:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
  data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
            
4003c890:	e2 00 60 1c 	ld  [ %g1 + 0x1c ], %l1
                       <== NOT EXECUTED
  const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);

4003c894:	b9 2f 60 01 	sll  %i5, 1, %i4
                              <== NOT EXECUTED
  data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
            
4003c898:	a0 04 61 be 	add  %l1, 0x1be, %l0
                          <== NOT EXECUTED
  const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);

4003c89c:	b8 07 00 1d 	add  %i4, %i5, %i4
                            <== NOT EXECUTED
  sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
 
4003c8a0:	96 07 bf f0 	add  %fp, -16, %o3
                            <== NOT EXECUTED
  const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);

4003c8a4:	b9 2f 20 04 	sll  %i4, 4, %i4
                              <== NOT EXECUTED
  sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
 
4003c8a8:	92 07 bf ec 	add  %fp, -20, %o1
                            <== NOT EXECUTED
  const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);

4003c8ac:	b8 06 80 1c 	add  %i2, %i4, %i4
                            <== NOT EXECUTED
  sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
 
4003c8b0:	90 10 00 10 	mov  %l0, %o0
                                 <== NOT EXECUTED
4003c8b4:	7f ff ff 25 	call  4003c548 <rtems_bdpart_read_mbr_partition>
<== NOT EXECUTED
4003c8b8:	94 10 00 1c 	mov  %i4, %o2
                                 <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL) {
                                      
4003c8bc:	b0 92 20 00 	orcc  %o0, 0, %i0
                             <== NOT EXECUTED
4003c8c0:	32 bf ff e7 	bne,a   4003c85c <rtems_bdpart_read+0x90>
     <== NOT EXECUTED
4003c8c4:	d0 07 bf f8 	ld  [ %fp + -8 ], %o0
                         <== NOT EXECUTED
  if (rtems_bdpart_mbr_partition_type( p->type) == RTEMS_BDPART_MBR_GPT) {

4003c8c8:	c2 07 bf ec 	ld  [ %fp + -20 ], %g1
                        <== NOT EXECUTED
4003c8cc:	c2 08 60 08 	ldub  [ %g1 + 8 ], %g1
                        <== NOT EXECUTED
4003c8d0:	80 a0 60 ee 	cmp  %g1, 0xee
                                <== NOT EXECUTED
4003c8d4:	02 bf ff e1 	be  4003c858 <rtems_bdpart_read+0x8c>
         <== NOT EXECUTED
4003c8d8:	b0 10 20 18 	mov  0x18, %i0
                                <== NOT EXECUTED
    block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
                  
4003c8dc:	c4 07 bf e8 	ld  [ %fp + -24 ], %g2
                        <== NOT EXECUTED
  format->type = RTEMS_BDPART_FORMAT_MBR;
                            
4003c8e0:	c0 26 40 00 	clr  [ %i1 ]
                                  <== NOT EXECUTED
  uint32_t value = 0;
                                                
4003c8e4:	82 10 20 00 	clr  %g1
                                      <== NOT EXECUTED
    block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
                  
4003c8e8:	c8 00 a0 1c 	ld  [ %g2 + 0x1c ], %g4
                       <== NOT EXECUTED
4003c8ec:	84 01 21 bb 	add  %g4, 0x1bb, %g2
                          <== NOT EXECUTED
4003c8f0:	88 01 21 b7 	add  %g4, 0x1b7, %g4
                          <== NOT EXECUTED
    value = (value << 8) + data [i];
                                 
4003c8f4:	c6 08 80 00 	ldub  [ %g2 ], %g3
                            <== NOT EXECUTED
4003c8f8:	83 28 60 08 	sll  %g1, 8, %g1
                              <== NOT EXECUTED
4003c8fc:	84 00 bf ff 	add  %g2, -1, %g2
                             <== NOT EXECUTED
  for (i = 3; i >= 0; --i) {
                                         
4003c900:	80 a0 80 04 	cmp  %g2, %g4
                                 <== NOT EXECUTED
4003c904:	12 bf ff fc 	bne  4003c8f4 <rtems_bdpart_read+0x128>
       <== NOT EXECUTED
4003c908:	82 00 c0 01 	add  %g3, %g1, %g1
                            <== NOT EXECUTED
  format->mbr.disk_id = rtems_uint32_from_little_endian(
             
4003c90c:	c2 26 60 04 	st  %g1, [ %i1 + 4 ]
                          <== NOT EXECUTED
  format->mbr.dos_compatibility = true;
                              
4003c910:	82 10 20 01 	mov  1, %g1
                                   <== NOT EXECUTED
4003c914:	c2 2e 60 08 	stb  %g1, [ %i1 + 8 ]
                         <== NOT EXECUTED
4003c918:	a2 04 61 ee 	add  %l1, 0x1ee, %l1
                          <== NOT EXECUTED
    data += RTEMS_BDPART_MBR_TABLE_ENTRY_SIZE;
                       
4003c91c:	a0 04 20 10 	add  %l0, 0x10, %l0
                           <== NOT EXECUTED
    sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);

4003c920:	96 07 bf f0 	add  %fp, -16, %o3
                            <== NOT EXECUTED
4003c924:	94 10 00 1c 	mov  %i4, %o2
                                 <== NOT EXECUTED
4003c928:	92 07 bf ec 	add  %fp, -20, %o1
                            <== NOT EXECUTED
4003c92c:	7f ff ff 07 	call  4003c548 <rtems_bdpart_read_mbr_partition>
<== NOT EXECUTED
4003c930:	90 10 00 10 	mov  %l0, %o0
                                 <== NOT EXECUTED
    if (sc != RTEMS_SUCCESSFUL) {
                                    
4003c934:	b0 92 20 00 	orcc  %o0, 0, %i0
                             <== NOT EXECUTED
4003c938:	12 bf ff c8 	bne  4003c858 <rtems_bdpart_read+0x8c>
        <== NOT EXECUTED
4003c93c:	80 a4 40 10 	cmp  %l1, %l0
                                 <== NOT EXECUTED
  for (i = 1; i < 4; ++i) {
                                          
4003c940:	32 bf ff f8 	bne,a   4003c920 <rtems_bdpart_read+0x154>
    <== NOT EXECUTED
4003c944:	a0 04 20 10 	add  %l0, 0x10, %l0
                           <== NOT EXECUTED
  ebr = ep_begin;
                                                    
4003c948:	fa 07 bf f0 	ld  [ %fp + -16 ], %i5
                        <== NOT EXECUTED
  while (ebr != 0) {
                                                 
4003c94c:	80 a7 60 00 	cmp  %i5, 0
                                   <== NOT EXECUTED
4003c950:	02 80 00 2c 	be  4003ca00 <rtems_bdpart_read+0x234>
        <== NOT EXECUTED
4003c954:	c8 07 bf ec 	ld  [ %fp + -20 ], %g4
                        <== NOT EXECUTED
    sc = rtems_bdpart_read_record( dd, ebr, &block);
                 
4003c958:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0
                         <== NOT EXECUTED
4003c95c:	94 07 bf e8 	add  %fp, -24, %o2
                            <== NOT EXECUTED
4003c960:	7f ff ff 36 	call  4003c638 <rtems_bdpart_read_record>
     <== NOT EXECUTED
4003c964:	92 10 00 1d 	mov  %i5, %o1
                                 <== NOT EXECUTED
    if (sc != RTEMS_SUCCESSFUL) {
                                    
4003c968:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
4003c96c:	12 80 00 36 	bne  4003ca44 <rtems_bdpart_read+0x278>
       <== NOT EXECUTED
4003c970:	c2 07 bf e8 	ld  [ %fp + -24 ], %g1
                        <== NOT EXECUTED
      block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,
               
4003c974:	d0 00 60 1c 	ld  [ %g1 + 0x1c ], %o0
                       <== NOT EXECUTED
    sc = rtems_bdpart_read_mbr_partition(
                            
4003c978:	96 10 20 00 	clr  %o3
                                      <== NOT EXECUTED
4003c97c:	94 10 00 1c 	mov  %i4, %o2
                                 <== NOT EXECUTED
4003c980:	92 07 bf ec 	add  %fp, -20, %o1
                            <== NOT EXECUTED
4003c984:	7f ff fe f1 	call  4003c548 <rtems_bdpart_read_mbr_partition>
<== NOT EXECUTED
4003c988:	90 02 21 be 	add  %o0, 0x1be, %o0
                          <== NOT EXECUTED
    if (sc != RTEMS_SUCCESSFUL) {
                                    
4003c98c:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
4003c990:	12 80 00 2d 	bne  4003ca44 <rtems_bdpart_read+0x278>
       <== NOT EXECUTED
4003c994:	c8 07 bf ec 	ld  [ %fp + -20 ], %g4
                        <== NOT EXECUTED
    tmp = p->begin + ebr;
                                            
4003c998:	c2 01 00 00 	ld  [ %g4 ], %g1
                              <== NOT EXECUTED
4003c99c:	84 00 40 1d 	add  %g1, %i5, %g2
                            <== NOT EXECUTED
    if (tmp > p->begin) {
                                            
4003c9a0:	80 a0 40 02 	cmp  %g1, %g2
                                 <== NOT EXECUTED
4003c9a4:	3a bf ff ad 	bcc,a   4003c858 <rtems_bdpart_read+0x8c>
     <== NOT EXECUTED
4003c9a8:	b0 10 20 1b 	mov  0x1b, %i0
                                <== NOT EXECUTED
      p->begin = tmp;
                                                
4003c9ac:	c4 21 00 00 	st  %g2, [ %g4 ]
                              <== NOT EXECUTED
    tmp = p->end + ebr;
                                              
4003c9b0:	c2 01 20 04 	ld  [ %g4 + 4 ], %g1
                          <== NOT EXECUTED
4003c9b4:	ba 00 40 1d 	add  %g1, %i5, %i5
                            <== NOT EXECUTED
    if (tmp > p->end) {
                                              
4003c9b8:	80 a0 40 1d 	cmp  %g1, %i5
                                 <== NOT EXECUTED
4003c9bc:	1a 80 00 20 	bcc  4003ca3c <rtems_bdpart_read+0x270>
       <== NOT EXECUTED
4003c9c0:	c4 07 bf e8 	ld  [ %fp + -24 ], %g2
                        <== NOT EXECUTED
      block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1
                
4003c9c4:	f2 00 a0 1c 	ld  [ %g2 + 0x1c ], %i1
                       <== NOT EXECUTED
      p->end = tmp;
                                                  
4003c9c8:	fa 21 20 04 	st  %i5, [ %g4 + 4 ]
                          <== NOT EXECUTED
  uint32_t value = 0;
                                                
4003c9cc:	82 10 20 00 	clr  %g1
                                      <== NOT EXECUTED
4003c9d0:	84 06 61 d9 	add  %i1, 0x1d9, %g2
                          <== NOT EXECUTED
4003c9d4:	ba 06 61 d5 	add  %i1, 0x1d5, %i5
                          <== NOT EXECUTED
    value = (value << 8) + data [i];
                                 
4003c9d8:	c6 08 80 00 	ldub  [ %g2 ], %g3
                            <== NOT EXECUTED
4003c9dc:	83 28 60 08 	sll  %g1, 8, %g1
                              <== NOT EXECUTED
4003c9e0:	84 00 bf ff 	add  %g2, -1, %g2
                             <== NOT EXECUTED
  for (i = 3; i >= 0; --i) {
                                         
4003c9e4:	80 a7 40 02 	cmp  %i5, %g2
                                 <== NOT EXECUTED
4003c9e8:	12 bf ff fc 	bne  4003c9d8 <rtems_bdpart_read+0x20c>
       <== NOT EXECUTED
4003c9ec:	82 00 c0 01 	add  %g3, %g1, %g1
                            <== NOT EXECUTED
  if (type == RTEMS_BDPART_MBR_EXTENDED) {
                           
4003c9f0:	c4 0e 61 d2 	ldub  [ %i1 + 0x1d2 ], %g2
                    <== NOT EXECUTED
4003c9f4:	80 a0 a0 05 	cmp  %g2, 5
                                   <== NOT EXECUTED
4003c9f8:	02 80 00 0a 	be  4003ca20 <rtems_bdpart_read+0x254>
        <== NOT EXECUTED
4003c9fc:	80 a0 60 00 	cmp  %g1, 0
                                   <== NOT EXECUTED
  *count = (size_t) (p - pt + 1);
                                    
4003ca00:	82 21 00 1a 	sub  %g4, %i2, %g1
                            <== NOT EXECUTED
4003ca04:	05 2a aa aa 	sethi  %hi(0xaaaaa800), %g2
                   <== NOT EXECUTED
4003ca08:	83 38 60 04 	sra  %g1, 4, %g1
                              <== NOT EXECUTED
4003ca0c:	84 10 a2 ab 	or  %g2, 0x2ab, %g2
                           <== NOT EXECUTED
4003ca10:	82 58 40 02 	smul  %g1, %g2, %g1
                           <== NOT EXECUTED
4003ca14:	82 00 60 01 	inc  %g1
                                      <== NOT EXECUTED
4003ca18:	10 bf ff 90 	b  4003c858 <rtems_bdpart_read+0x8c>
          <== NOT EXECUTED
4003ca1c:	c2 26 c0 00 	st  %g1, [ %i3 ]
                              <== NOT EXECUTED
    if (ebr != 0) {
                                                  
4003ca20:	22 bf ff f9 	be,a   4003ca04 <rtems_bdpart_read+0x238>
     <== NOT EXECUTED
4003ca24:	82 21 00 1a 	sub  %g4, %i2, %g1
                            <== NOT EXECUTED
      tmp = ebr + ep_begin;
                                          
4003ca28:	fa 07 bf f0 	ld  [ %fp + -16 ], %i5
                        <== NOT EXECUTED
4003ca2c:	ba 00 40 1d 	add  %g1, %i5, %i5
                            <== NOT EXECUTED
      if (tmp > ebr) {
                                               
4003ca30:	80 a7 40 01 	cmp  %i5, %g1
                                 <== NOT EXECUTED
4003ca34:	18 bf ff ca 	bgu  4003c95c <rtems_bdpart_read+0x190>
       <== NOT EXECUTED
4003ca38:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0
                         <== NOT EXECUTED
      esc = RTEMS_IO_ERROR;
                                          
4003ca3c:	10 bf ff 87 	b  4003c858 <rtems_bdpart_read+0x8c>
          <== NOT EXECUTED
4003ca40:	b0 10 20 1b 	mov  0x1b, %i0
                                <== NOT EXECUTED
    sc = rtems_bdpart_read_mbr_partition(
                            
4003ca44:	10 bf ff 85 	b  4003c858 <rtems_bdpart_read+0x8c>
          <== NOT EXECUTED
4003ca48:	b0 10 00 08 	mov  %o0, %i0
                                 <== NOT EXECUTED

                                                                     
===============================================================================
400070c4 <rtems_bdpart_register>:
                                    
rtems_status_code rtems_bdpart_register(
                             
  const char *disk_name,
                                             
  const rtems_bdpart_partition *pt,
                                  
  size_t count
                                                       
)
                                                                    
{
                                                                    
400070c4:	9d e3 bf 90 	save  %sp, -112, %sp
                          <== NOT EXECUTED
  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;
                                                       
400070c8:	82 10 3f ff 	mov  -1, %g1
                                  <== NOT EXECUTED
  rtems_disk_device *dd = NULL;
                                      

                                                                     
  /* Get disk data */
                                                
  sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
  
400070cc:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
{
                                                                    
400070d0:	b8 10 00 18 	mov  %i0, %i4
                                 <== NOT EXECUTED
  rtems_blkdev_bnum disk_end = 0;
                                    
400070d4:	c0 27 bf f0 	clr  [ %fp + -16 ]
                            <== NOT EXECUTED
  sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
  
400070d8:	96 07 bf f0 	add  %fp, -16, %o3
                            <== NOT EXECUTED
  char *logical_disk_marker = NULL;
                                  
400070dc:	c0 27 bf f4 	clr  [ %fp + -12 ]
                            <== NOT EXECUTED
  sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
  
400070e0:	94 07 bf fc 	add  %fp, -4, %o2
                             <== NOT EXECUTED
  int fd = -1;
                                                       
400070e4:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]
                         <== NOT EXECUTED
  sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
  
400070e8:	92 07 bf f8 	add  %fp, -8, %o1
                             <== NOT EXECUTED
400070ec:	40 00 d5 88 	call  4003c70c <rtems_bdpart_get_disk_data>
   <== NOT EXECUTED
400070f0:	c0 27 bf fc 	clr  [ %fp + -4 ]
                             <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL) {
                                      
400070f4:	b0 92 20 00 	orcc  %o0, 0, %i0
                             <== NOT EXECUTED
400070f8:	12 80 00 24 	bne  40007188 <rtems_bdpart_register+0xc4>
    <== NOT EXECUTED
400070fc:	92 07 bf f4 	add  %fp, -12, %o1
                            <== NOT EXECUTED
    return sc;
                                                       
  }
                                                                  

                                                                     
  /* Create logical disk name */
                                     
  logical_disk_name = create_logical_disk_name(
                      
40007100:	7f ff ff e2 	call  40007088 <create_logical_disk_name>
     <== NOT EXECUTED
40007104:	90 10 00 1c 	mov  %i4, %o0
                                 <== NOT EXECUTED
    disk_name,
                                                       
    &logical_disk_marker
                                             
  );
                                                                 
  if (logical_disk_name == NULL) {
                                   
40007108:	b6 92 20 00 	orcc  %o0, 0, %i3
                             <== NOT EXECUTED
4000710c:	02 80 00 1b 	be  40007178 <rtems_bdpart_register+0xb4>
     <== NOT EXECUTED
40007110:	80 a6 a0 00 	cmp  %i2, 0
                                   <== NOT EXECUTED
    esc = sc;
                                                        
    goto cleanup;
                                                    
  }
                                                                  

                                                                     
  /* Create a logical disk for each partition */
                     
  for (i = 0; i < count; ++i) {
                                      
40007114:	02 80 00 19 	be  40007178 <rtems_bdpart_register+0xb4>
     <== NOT EXECUTED
40007118:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);

4000711c:	21 10 02 12 	sethi  %hi(0x40084800), %l0
                   <== NOT EXECUTED
  for (i = 0; i < count; ++i) {
                                      
40007120:	ba 10 20 00 	clr  %i5
                                      <== NOT EXECUTED
  rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);

40007124:	10 80 00 0a 	b  4000714c <rtems_bdpart_register+0x88>
      <== NOT EXECUTED
40007128:	a0 14 20 b0 	or  %l0, 0xb0, %l0
                            <== NOT EXECUTED
      esc = sc;
                                                      
      goto cleanup;
                                                  
    }
                                                                

                                                                     
    /* Create logical disk */
                                        
    sc = rtems_blkdev_create_partition(
                              
4000712c:	d4 1e 40 00 	ldd  [ %i1 ], %o2
                             <== NOT EXECUTED
40007130:	40 00 01 32 	call  400075f8 <rtems_blkdev_create_partition>
<== NOT EXECUTED
40007134:	96 22 c0 0a 	sub  %o3, %o2, %o3
                            <== NOT EXECUTED
      logical_disk_name,
                                             
      disk_name,
                                                     
      p->begin,
                                                      
      p->end - p->begin
                                              
    );
                                                               
    if (sc != RTEMS_SUCCESSFUL) {
                                    
40007138:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
4000713c:	12 80 00 15 	bne  40007190 <rtems_bdpart_register+0xcc>
    <== NOT EXECUTED
40007140:	80 a6 80 1d 	cmp  %i2, %i5
                                 <== NOT EXECUTED
  for (i = 0; i < count; ++i) {
                                      
40007144:	02 80 00 0d 	be  40007178 <rtems_bdpart_register+0xb4>
     <== NOT EXECUTED
40007148:	b2 06 60 30 	add  %i1, 0x30, %i1
                           <== NOT EXECUTED
  rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);

4000714c:	d0 07 bf f4 	ld  [ %fp + -12 ], %o0
                        <== NOT EXECUTED
40007150:	92 10 20 04 	mov  4, %o1
                                   <== NOT EXECUTED
40007154:	ba 07 60 01 	inc  %i5
                                      <== NOT EXECUTED
40007158:	94 10 00 10 	mov  %l0, %o2
                                 <== NOT EXECUTED
4000715c:	40 01 71 2c 	call  4006360c <snprintf>
                     <== NOT EXECUTED
40007160:	96 10 00 1d 	mov  %i5, %o3
                                 <== NOT EXECUTED
    sc = rtems_blkdev_create_partition(
                              
40007164:	92 10 00 1c 	mov  %i4, %o1
                                 <== NOT EXECUTED
  if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
                              
40007168:	80 a2 20 03 	cmp  %o0, 3
                                   <== NOT EXECUTED
4000716c:	04 bf ff f0 	ble  4000712c <rtems_bdpart_register+0x68>
    <== NOT EXECUTED
40007170:	90 10 00 1b 	mov  %i3, %o0
                                 <== NOT EXECUTED
    sc = RTEMS_INVALID_NAME;
                                         
40007174:	b0 10 20 03 	mov  3, %i0
                                   <== NOT EXECUTED
    }
                                                                
  }
                                                                  

                                                                     
cleanup:
                                                             

                                                                     
  free( logical_disk_name);
                                          
40007178:	40 00 11 42 	call  4000b680 <free>
                         <== NOT EXECUTED
4000717c:	90 10 00 1b 	mov  %i3, %o0
                                 <== NOT EXECUTED
  close( fd);
                                                        
40007180:	40 00 10 7b 	call  4000b36c <close>
                        <== NOT EXECUTED
40007184:	d0 07 bf f8 	ld  [ %fp + -8 ], %o0
                         <== NOT EXECUTED

                                                                     
  return esc;
                                                        
}
                                                                    
40007188:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4000718c:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
    sc = rtems_blkdev_create_partition(
                              
40007190:	10 bf ff fa 	b  40007178 <rtems_bdpart_register+0xb4>
      <== NOT EXECUTED
40007194:	b0 10 00 08 	mov  %o0, %i0
                                 <== NOT EXECUTED

                                                                     
===============================================================================
40007198 <rtems_bdpart_register_from_disk>:
                          

                                                                     
rtems_status_code rtems_bdpart_register_from_disk( const char *disk_name)

{
                                                                    
40007198:	9d e3 bc 88 	save  %sp, -888, %sp
                          <== NOT EXECUTED
  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;
                 
4000719c:	82 10 20 10 	mov  0x10, %g1
                                <== NOT EXECUTED

                                                                     
  /* Read partitions */
                                              
  sc = rtems_bdpart_read( disk_name, &format, pt, &count);
           
400071a0:	96 07 bc e8 	add  %fp, -792, %o3
                           <== NOT EXECUTED
  size_t count = RTEMS_BDPART_PARTITION_NUMBER_HINT;
                 
400071a4:	c2 27 bc e8 	st  %g1, [ %fp + -792 ]
                       <== NOT EXECUTED
  sc = rtems_bdpart_read( disk_name, &format, pt, &count);
           
400071a8:	94 07 bd 00 	add  %fp, -768, %o2
                           <== NOT EXECUTED
400071ac:	92 07 bc ec 	add  %fp, -788, %o1
                           <== NOT EXECUTED
400071b0:	40 00 d5 87 	call  4003c7cc <rtems_bdpart_read>
            <== NOT EXECUTED
400071b4:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL) {
                                      
400071b8:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
400071bc:	12 80 00 05 	bne  400071d0 <rtems_bdpart_register_from_disk+0x38>
<== NOT EXECUTED
400071c0:	d4 07 bc e8 	ld  [ %fp + -792 ], %o2
                       <== NOT EXECUTED
    return sc;
                                                       
  }
                                                                  

                                                                     
  /* Register partitions */
                                          
  return rtems_bdpart_register( disk_name, pt, count);
               
400071c4:	92 07 bd 00 	add  %fp, -768, %o1
                           <== NOT EXECUTED
400071c8:	7f ff ff bf 	call  400070c4 <rtems_bdpart_register>
        <== NOT EXECUTED
400071cc:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
}
                                                                    
400071d0:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
400071d4:	91 e8 00 08 	restore  %g0, %o0, %o0
                        <== NOT EXECUTED

                                                                     
===============================================================================
4003c6dc <rtems_bdpart_to_mbr_partition_type>:
                       
{
                                                                    
4003c6dc:	9d e3 bf a0 	save  %sp, -96, %sp
                           <== NOT EXECUTED
4003c6e0:	c2 0e 00 00 	ldub  [ %i0 ], %g1
                            <== NOT EXECUTED
  *mbr_type = rtems_bdpart_mbr_partition_type( type);
                
4003c6e4:	c2 2e 40 00 	stb  %g1, [ %i1 ]
                             <== NOT EXECUTED
  return memcmp(
                                                     
4003c6e8:	94 10 20 0f 	mov  0xf, %o2
                                 <== NOT EXECUTED
4003c6ec:	90 06 20 01 	add  %i0, 1, %o0
                              <== NOT EXECUTED
4003c6f0:	13 10 02 0b 	sethi  %hi(0x40082c00), %o1
                   <== NOT EXECUTED
4003c6f4:	40 00 92 0e 	call  40060f2c <memcmp>
                       <== NOT EXECUTED
4003c6f8:	92 12 60 59 	or  %o1, 0x59, %o1	! 40082c59 <RTEMS_BDPART_MBR_MASTER_TYPE+0x1>
<== NOT EXECUTED
}
                                                                    
4003c6fc:	80 a0 00 08 	cmp  %g0, %o0
                                 <== NOT EXECUTED
4003c700:	b0 60 3f ff 	subx  %g0, -1, %i0
                            <== NOT EXECUTED
4003c704:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4003c708:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED

                                                                     
===============================================================================
4003c6b8 <rtems_bdpart_to_partition_type>:
                           
  type [0] = mbr_type;
                                               
4003c6b8:	d0 2a 40 00 	stb  %o0, [ %o1 ]
                             <== NOT EXECUTED
{
                                                                    
4003c6bc:	82 10 00 09 	mov  %o1, %g1
                                 <== NOT EXECUTED
  memcpy( type + 1, RTEMS_BDPART_MBR_MASTER_TYPE + 1, sizeof( uuid_t) - 1);

4003c6c0:	94 10 20 0f 	mov  0xf, %o2
                                 <== NOT EXECUTED
4003c6c4:	13 10 02 0b 	sethi  %hi(0x40082c00), %o1
                   <== NOT EXECUTED
4003c6c8:	90 00 60 01 	add  %g1, 1, %o0
                              <== NOT EXECUTED
4003c6cc:	92 12 60 59 	or  %o1, 0x59, %o1
                            <== NOT EXECUTED
4003c6d0:	82 13 c0 00 	mov  %o7, %g1
                                 <== NOT EXECUTED
4003c6d4:	40 00 92 3f 	call  40060fd0 <memcpy>
                       <== NOT EXECUTED
4003c6d8:	9e 10 40 00 	mov  %g1, %o7
                                 <== NOT EXECUTED

                                                                     
===============================================================================
4003c410 <rtems_bdpart_unmount>:
                                     
  const char *disk_name,
                                             
  const rtems_bdpart_partition *pt RTEMS_UNUSED,
                     
  size_t count,
                                                      
  const char *mount_base
                                             
)
                                                                    
{
                                                                    
4003c410:	9d e3 bf a0 	save  %sp, -96, %sp
                           <== NOT EXECUTED
  rtems_status_code esc = RTEMS_SUCCESSFUL;
                          
  const char *disk_file_name = strrchr( disk_name, '/');
             
4003c414:	92 10 20 2f 	mov  0x2f, %o1
                                <== NOT EXECUTED
4003c418:	40 00 a5 ce 	call  40065b50 <strrchr>
                      <== NOT EXECUTED
4003c41c:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
4003c420:	b8 10 00 08 	mov  %o0, %i4
                                 <== NOT EXECUTED
  char *mount_point = NULL;
                                          
  char *mount_marker = NULL;
                                         
  size_t disk_file_name_size = 0;
                                    
  size_t disk_name_size = strlen( disk_name);
                        
4003c424:	40 00 a0 b7 	call  40064700 <strlen>
                       <== NOT EXECUTED
4003c428:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
4003c42c:	a2 10 00 08 	mov  %o0, %l1
                                 <== NOT EXECUTED
  size_t mount_base_size = strlen( mount_base);
                      
4003c430:	40 00 a0 b4 	call  40064700 <strlen>
                       <== NOT EXECUTED
4003c434:	90 10 00 1b 	mov  %i3, %o0
                                 <== NOT EXECUTED
{
                                                                    
4003c438:	ba 10 00 18 	mov  %i0, %i5
                                 <== NOT EXECUTED
  size_t i = 0;
                                                      

                                                                     
  /* Get disk file name */
                                           
  if (disk_file_name != NULL) {
                                      
4003c43c:	80 a7 20 00 	cmp  %i4, 0
                                   <== NOT EXECUTED
4003c440:	02 80 00 06 	be  4003c458 <rtems_bdpart_unmount+0x48>
      <== NOT EXECUTED
4003c444:	a0 10 00 08 	mov  %o0, %l0
                                 <== NOT EXECUTED
    disk_file_name += 1;
                                             
4003c448:	ba 07 20 01 	add  %i4, 1, %i5
                              <== NOT EXECUTED
    disk_file_name_size = strlen( disk_file_name);
                   
4003c44c:	40 00 a0 ad 	call  40064700 <strlen>
                       <== NOT EXECUTED
4003c450:	90 10 00 1d 	mov  %i5, %o0
                                 <== NOT EXECUTED
4003c454:	a2 10 00 08 	mov  %o0, %l1
                                 <== NOT EXECUTED
    disk_file_name = disk_name;
                                      
    disk_file_name_size = disk_name_size;
                            
  }
                                                                  

                                                                     
  /* Create mount point base */
                                      
  mount_point = malloc( mount_base_size + 1 + disk_file_name_size + RTEMS_BDPART_NUMBER_SIZE);

4003c458:	b2 04 40 10 	add  %l1, %l0, %i1
                            <== NOT EXECUTED
  if (mount_point == NULL) {
                                         
    esc = RTEMS_NO_MEMORY;
                                           
4003c45c:	b0 10 20 1a 	mov  0x1a, %i0
                                <== NOT EXECUTED
  mount_point = malloc( mount_base_size + 1 + disk_file_name_size + RTEMS_BDPART_NUMBER_SIZE);

4003c460:	7f ff 3e 4b 	call  4000bd8c <malloc>
                       <== NOT EXECUTED
4003c464:	90 06 60 05 	add  %i1, 5, %o0
                              <== NOT EXECUTED
  if (mount_point == NULL) {
                                         
4003c468:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
4003c46c:	02 80 00 2b 	be  4003c518 <rtems_bdpart_unmount+0x108>
     <== NOT EXECUTED
4003c470:	b8 10 00 08 	mov  %o0, %i4
                                 <== NOT EXECUTED
    goto cleanup;
                                                    
  }
                                                                  
  strncpy( mount_point, mount_base, mount_base_size);
                
4003c474:	92 10 00 1b 	mov  %i3, %o1
                                 <== NOT EXECUTED
4003c478:	40 00 a1 4c 	call  400649a8 <strncpy>
                      <== NOT EXECUTED
4003c47c:	94 10 00 10 	mov  %l0, %o2
                                 <== NOT EXECUTED
  mount_point [mount_base_size] = '/';
                               
4003c480:	82 10 20 2f 	mov  0x2f, %g1
                                <== NOT EXECUTED
4003c484:	c2 2f 00 10 	stb  %g1, [ %i4 + %l0 ]
                       <== NOT EXECUTED
  strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);

4003c488:	92 10 00 1d 	mov  %i5, %o1
                                 <== NOT EXECUTED
4003c48c:	94 10 00 11 	mov  %l1, %o2
                                 <== NOT EXECUTED
4003c490:	90 04 20 01 	add  %l0, 1, %o0
                              <== NOT EXECUTED
4003c494:	40 00 a1 45 	call  400649a8 <strncpy>
                      <== NOT EXECUTED
4003c498:	90 07 00 08 	add  %i4, %o0, %o0
                            <== NOT EXECUTED

                                                                     
  /* Marker */
                                                       
  mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;

4003c49c:	b6 06 60 01 	add  %i1, 1, %i3
                              <== NOT EXECUTED

                                                                     
  /* Mount supported file systems for each partition */
              
  for (i = 0; i < count; ++i) {
                                      
4003c4a0:	ba 10 20 00 	clr  %i5
                                      <== NOT EXECUTED
    /* Create mount point */
                                         
    int rv = snprintf( mount_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);

4003c4a4:	33 10 02 12 	sethi  %hi(0x40084800), %i1
                   <== NOT EXECUTED
  mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;

4003c4a8:	b6 07 00 1b 	add  %i4, %i3, %i3
                            <== NOT EXECUTED
  for (i = 0; i < count; ++i) {
                                      
4003c4ac:	80 a6 a0 00 	cmp  %i2, 0
                                   <== NOT EXECUTED
4003c4b0:	12 80 00 06 	bne  4003c4c8 <rtems_bdpart_unmount+0xb8>
     <== NOT EXECUTED
4003c4b4:	b2 16 60 b0 	or  %i1, 0xb0, %i1
                            <== NOT EXECUTED
  rtems_status_code esc = RTEMS_SUCCESSFUL;
                          
4003c4b8:	10 80 00 1c 	b  4003c528 <rtems_bdpart_unmount+0x118>
      <== NOT EXECUTED
4003c4bc:	b0 10 20 00 	clr  %i0
                                      <== NOT EXECUTED
  for (i = 0; i < count; ++i) {
                                      
4003c4c0:	02 80 00 1a 	be  4003c528 <rtems_bdpart_unmount+0x118>
     <== NOT EXECUTED
4003c4c4:	b0 10 20 00 	clr  %i0
                                      <== NOT EXECUTED
    int rv = snprintf( mount_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);

4003c4c8:	94 10 00 19 	mov  %i1, %o2
                                 <== NOT EXECUTED
4003c4cc:	92 10 20 04 	mov  4, %o1
                                   <== NOT EXECUTED
4003c4d0:	ba 07 60 01 	inc  %i5
                                      <== NOT EXECUTED
4003c4d4:	90 10 00 1b 	mov  %i3, %o0
                                 <== NOT EXECUTED
4003c4d8:	40 00 9c 4d 	call  4006360c <snprintf>
                     <== NOT EXECUTED
4003c4dc:	96 10 00 1d 	mov  %i5, %o3
                                 <== NOT EXECUTED
    if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
                            
4003c4e0:	80 a2 20 03 	cmp  %o0, 3
                                   <== NOT EXECUTED
4003c4e4:	14 80 00 15 	bg  4003c538 <rtems_bdpart_unmount+0x128>
     <== NOT EXECUTED
4003c4e8:	b0 10 20 03 	mov  3, %i0
                                   <== NOT EXECUTED
      esc = RTEMS_INVALID_NAME;
                                      
      goto cleanup;
                                                  
    }
                                                                

                                                                     
    /* Unmount */
                                                    
    rv = unmount( mount_point);
                                      
4003c4ec:	40 00 1c 90 	call  4004372c <unmount>
                      <== NOT EXECUTED
4003c4f0:	90 10 00 1c 	mov  %i4, %o0
                                 <== NOT EXECUTED
    if (rv == 0) {
                                                   
4003c4f4:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
4003c4f8:	12 bf ff f2 	bne  4003c4c0 <rtems_bdpart_unmount+0xb0>
     <== NOT EXECUTED
4003c4fc:	80 a7 40 1a 	cmp  %i5, %i2
                                 <== NOT EXECUTED
      /* Remove mount point */
                                       
      rv = rmdir( mount_point);
                                      
4003c500:	40 00 1b 38 	call  400431e0 <rmdir>
                        <== NOT EXECUTED
4003c504:	90 10 00 1c 	mov  %i4, %o0
                                 <== NOT EXECUTED
      if (rv != 0) {
                                                 
4003c508:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
4003c50c:	02 bf ff ed 	be  4003c4c0 <rtems_bdpart_unmount+0xb0>
      <== NOT EXECUTED
4003c510:	80 a7 40 1a 	cmp  %i5, %i2
                                 <== NOT EXECUTED
        esc = RTEMS_IO_ERROR;
                                        
4003c514:	b0 10 20 1b 	mov  0x1b, %i0
                                <== NOT EXECUTED
    }
                                                                
  }
                                                                  

                                                                     
cleanup:
                                                             

                                                                     
  free( mount_point);
                                                
4003c518:	7f ff 3c 5a 	call  4000b680 <free>
                         <== NOT EXECUTED
4003c51c:	90 10 00 1c 	mov  %i4, %o0
                                 <== NOT EXECUTED

                                                                     
  return esc;
                                                        
}
                                                                    
4003c520:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4003c524:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
  free( mount_point);
                                                
4003c528:	7f ff 3c 56 	call  4000b680 <free>
                         <== NOT EXECUTED
4003c52c:	90 10 00 1c 	mov  %i4, %o0
                                 <== NOT EXECUTED
}
                                                                    
4003c530:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4003c534:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
  free( mount_point);
                                                
4003c538:	7f ff 3c 52 	call  4000b680 <free>
                         <== NOT EXECUTED
4003c53c:	90 10 00 1c 	mov  %i4, %o0
                                 <== NOT EXECUTED
}
                                                                    
4003c540:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4003c544:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED

                                                                     
===============================================================================
400071d8 <rtems_bdpart_unregister>:
                                  
rtems_status_code rtems_bdpart_unregister(
                           
  const char *disk_name,
                                             
  const rtems_bdpart_partition *pt RTEMS_UNUSED,
                     
  size_t count
                                                       
)
                                                                    
{
                                                                    
400071d8:	9d e3 bf 90 	save  %sp, -112, %sp
                          <== NOT EXECUTED
  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;
                                                       
400071dc:	82 10 3f ff 	mov  -1, %g1
                                  <== NOT EXECUTED
  rtems_blkdev_bnum disk_end = 0;
                                    
400071e0:	c0 27 bf f0 	clr  [ %fp + -16 ]
                            <== NOT EXECUTED
  rtems_disk_device *dd = NULL;
                                      

                                                                     
  /* Get disk data */
                                                
  sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
  
400071e4:	96 07 bf f0 	add  %fp, -16, %o3
                            <== NOT EXECUTED
  char *logical_disk_marker = NULL;
                                  
400071e8:	c0 27 bf f4 	clr  [ %fp + -12 ]
                            <== NOT EXECUTED
  sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
  
400071ec:	94 07 bf fc 	add  %fp, -4, %o2
                             <== NOT EXECUTED
  int fd = -1;
                                                       
400071f0:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]
                         <== NOT EXECUTED
  sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
  
400071f4:	92 07 bf f8 	add  %fp, -8, %o1
                             <== NOT EXECUTED
  rtems_disk_device *dd = NULL;
                                      
400071f8:	c0 27 bf fc 	clr  [ %fp + -4 ]
                             <== NOT EXECUTED
  sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
  
400071fc:	40 00 d5 44 	call  4003c70c <rtems_bdpart_get_disk_data>
   <== NOT EXECUTED
40007200:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL) {
                                      
40007204:	b8 92 20 00 	orcc  %o0, 0, %i4
                             <== NOT EXECUTED
40007208:	02 80 00 04 	be  40007218 <rtems_bdpart_unregister+0x40>
   <== NOT EXECUTED
4000720c:	92 07 bf f4 	add  %fp, -12, %o1
                            <== NOT EXECUTED

                                                                     
  free( logical_disk_name);
                                          
  close( fd);
                                                        

                                                                     
  return esc;
                                                        
}
                                                                    
40007210:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40007214:	91 e8 00 1c 	restore  %g0, %i4, %o0
                        <== NOT EXECUTED
  logical_disk_name = create_logical_disk_name(
                      
40007218:	7f ff ff 9c 	call  40007088 <create_logical_disk_name>
     <== NOT EXECUTED
4000721c:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
  if (logical_disk_name == NULL) {
                                   
40007220:	b6 92 20 00 	orcc  %o0, 0, %i3
                             <== NOT EXECUTED
40007224:	02 80 00 19 	be  40007288 <rtems_bdpart_unregister+0xb0>
   <== NOT EXECUTED
40007228:	80 a6 a0 00 	cmp  %i2, 0
                                   <== NOT EXECUTED
  for (i = 0; i < count; ++i) {
                                      
4000722c:	02 80 00 17 	be  40007288 <rtems_bdpart_unregister+0xb0>
   <== NOT EXECUTED
40007230:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);

40007234:	33 10 02 12 	sethi  %hi(0x40084800), %i1
                   <== NOT EXECUTED
  for (i = 0; i < count; ++i) {
                                      
40007238:	ba 10 20 00 	clr  %i5
                                      <== NOT EXECUTED
  rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);

4000723c:	10 80 00 09 	b  40007260 <rtems_bdpart_unregister+0x88>
    <== NOT EXECUTED
40007240:	b2 16 60 b0 	or  %i1, 0xb0, %i1
                            <== NOT EXECUTED
    rv = unlink( logical_disk_name);
                                 
40007244:	40 00 24 7d 	call  40010438 <unlink>
                       <== NOT EXECUTED
40007248:	90 10 00 1b 	mov  %i3, %o0
                                 <== NOT EXECUTED
    if (rv != 0) {
                                                   
4000724c:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
40007250:	12 80 00 0e 	bne  40007288 <rtems_bdpart_unregister+0xb0>
  <== NOT EXECUTED
40007254:	80 a6 80 1d 	cmp  %i2, %i5
                                 <== NOT EXECUTED
  for (i = 0; i < count; ++i) {
                                      
40007258:	02 80 00 0c 	be  40007288 <rtems_bdpart_unregister+0xb0>
   <== NOT EXECUTED
4000725c:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);

40007260:	d0 07 bf f4 	ld  [ %fp + -12 ], %o0
                        <== NOT EXECUTED
40007264:	ba 07 60 01 	inc  %i5
                                      <== NOT EXECUTED
40007268:	94 10 00 19 	mov  %i1, %o2
                                 <== NOT EXECUTED
4000726c:	96 10 00 1d 	mov  %i5, %o3
                                 <== NOT EXECUTED
40007270:	40 01 70 e7 	call  4006360c <snprintf>
                     <== NOT EXECUTED
40007274:	92 10 20 04 	mov  4, %o1
                                   <== NOT EXECUTED
  if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
                              
40007278:	80 a2 20 03 	cmp  %o0, 3
                                   <== NOT EXECUTED
4000727c:	04 bf ff f2 	ble  40007244 <rtems_bdpart_unregister+0x6c>
  <== NOT EXECUTED
40007280:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
    sc = RTEMS_INVALID_NAME;
                                         
40007284:	b8 10 20 03 	mov  3, %i4	! 3 <_TLS_Alignment+0x2>
          <== NOT EXECUTED
  free( logical_disk_name);
                                          
40007288:	40 00 10 fe 	call  4000b680 <free>
                         <== NOT EXECUTED
4000728c:	90 10 00 1b 	mov  %i3, %o0
                                 <== NOT EXECUTED
  close( fd);
                                                        
40007290:	40 00 10 37 	call  4000b36c <close>
                        <== NOT EXECUTED
40007294:	d0 07 bf f8 	ld  [ %fp + -8 ], %o0
                         <== NOT EXECUTED
}
                                                                    
40007298:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4000729c:	91 e8 00 1c 	restore  %g0, %i4, %o0
                        <== NOT EXECUTED

                                                                     
===============================================================================
4003cadc <rtems_bdpart_write>:
                                       
  const char *disk_name,
                                             
  const rtems_bdpart_format *format,
                                 
  const rtems_bdpart_partition *pt,
                                  
  size_t count
                                                       
)
                                                                    
{
                                                                    
4003cadc:	9d e3 bf 88 	save  %sp, -120, %sp
                          <== NOT EXECUTED
  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;
                                
4003cae0:	80 a6 60 00 	cmp  %i1, 0
                                   <== NOT EXECUTED
4003cae4:	22 80 00 07 	be,a   4003cb00 <rtems_bdpart_write+0x24>
     <== NOT EXECUTED
4003cae8:	c0 27 bf f0 	clr  [ %fp + -16 ]
                            <== NOT EXECUTED
    && format->type == RTEMS_BDPART_FORMAT_MBR
                       
4003caec:	c2 06 40 00 	ld  [ %i1 ], %g1
                              <== NOT EXECUTED
4003caf0:	80 a0 60 00 	cmp  %g1, 0
                                   <== NOT EXECUTED
4003caf4:	22 80 00 4e 	be,a   4003cc2c <rtems_bdpart_write+0x150>
    <== NOT EXECUTED
4003caf8:	c2 0e 60 08 	ldub  [ %i1 + 8 ], %g1
                        <== NOT EXECUTED
  rtems_bdbuf_buffer *block = NULL;
                                  
4003cafc:	c0 27 bf f0 	clr  [ %fp + -16 ]
                            <== NOT EXECUTED
  rtems_blkdev_bnum disk_end = 0;
                                    
4003cb00:	a2 10 20 00 	clr  %l1
                                      <== NOT EXECUTED
4003cb04:	c0 27 bf f4 	clr  [ %fp + -12 ]
                            <== NOT EXECUTED
  rtems_blkdev_bnum record_space =
                                   
    dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;
          
4003cb08:	a0 10 20 01 	mov  1, %l0
                                   <== NOT EXECUTED
  size_t ppc = 0; /* Primary partition count */
                      
  size_t i = 0;
                                                      
  uint8_t *data = NULL;
                                              
  int fd = -1;
                                                       
4003cb0c:	82 10 3f ff 	mov  -1, %g1
                                  <== NOT EXECUTED
  rtems_disk_device *dd = NULL;
                                      
4003cb10:	c0 27 bf fc 	clr  [ %fp + -4 ]
                             <== NOT EXECUTED

                                                                     
  /* Check if we have something to do */
                             
  if (count == 0) {
                                                  
    /* Nothing to do */
                                              
    return RTEMS_SUCCESSFUL;
                                         
4003cb14:	ba 10 20 00 	clr  %i5
                                      <== NOT EXECUTED
  if (count == 0) {
                                                  
4003cb18:	80 a6 e0 00 	cmp  %i3, 0
                                   <== NOT EXECUTED
4003cb1c:	02 80 00 42 	be  4003cc24 <rtems_bdpart_write+0x148>
       <== NOT EXECUTED
4003cb20:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]
                         <== NOT EXECUTED
  }
                                                                  

                                                                     
  /* Check parameter */
                                              
  if (format == NULL || pt == NULL) {
                                
4003cb24:	80 a6 60 00 	cmp  %i1, 0
                                   <== NOT EXECUTED
4003cb28:	02 80 00 48 	be  4003cc48 <rtems_bdpart_write+0x16c>
       <== NOT EXECUTED
4003cb2c:	80 a6 a0 00 	cmp  %i2, 0
                                   <== NOT EXECUTED
4003cb30:	02 80 00 46 	be  4003cc48 <rtems_bdpart_write+0x16c>
       <== NOT EXECUTED
4003cb34:	96 07 bf f4 	add  %fp, -12, %o3
                            <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;
                                    
  }
                                                                  

                                                                     
  /* Get disk data */
                                                
  sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
  
4003cb38:	94 07 bf fc 	add  %fp, -4, %o2
                             <== NOT EXECUTED
4003cb3c:	92 07 bf f8 	add  %fp, -8, %o1
                             <== NOT EXECUTED
4003cb40:	7f ff fe f3 	call  4003c70c <rtems_bdpart_get_disk_data>
   <== NOT EXECUTED
4003cb44:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL) {
                                      
4003cb48:	ba 92 20 00 	orcc  %o0, 0, %i5
                             <== NOT EXECUTED
4003cb4c:	12 80 00 36 	bne  4003cc24 <rtems_bdpart_write+0x148>
      <== NOT EXECUTED
4003cb50:	80 a4 60 00 	cmp  %l1, 0
                                   <== NOT EXECUTED
    return sc;
                                                       
  }
                                                                  

                                                                     
  /* Align end of disk on cylinder boundary if necessary */
          
  if (dos_compatibility) {
                                           
4003cb54:	02 80 00 09 	be  4003cb78 <rtems_bdpart_write+0x9c>
        <== NOT EXECUTED
4003cb58:	c8 07 bf f4 	ld  [ %fp + -12 ], %g4
                        <== NOT EXECUTED
    disk_end -= (disk_end % record_space);
                           
4003cb5c:	81 80 20 00 	wr  %g0, %y
                                   <== NOT EXECUTED
4003cb60:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
4003cb64:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
4003cb68:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
4003cb6c:	82 71 00 10 	udiv  %g4, %l0, %g1
                           <== NOT EXECUTED
4003cb70:	88 58 40 10 	smul  %g1, %l0, %g4
                           <== NOT EXECUTED
4003cb74:	c8 27 bf f4 	st  %g4, [ %fp + -12 ]
                        <== NOT EXECUTED
  /* 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) {
                 
4003cb78:	f0 06 80 00 	ld  [ %i2 ], %i0
                              <== NOT EXECUTED
4003cb7c:	80 a6 00 04 	cmp  %i0, %g4
                                 <== NOT EXECUTED
4003cb80:	3a 80 00 1d 	bcc,a   4003cbf4 <rtems_bdpart_write+0x118>
   <== NOT EXECUTED
4003cb84:	ba 10 20 0a 	mov  0xa, %i5
                                 <== NOT EXECUTED
4003cb88:	c2 06 a0 04 	ld  [ %i2 + 4 ], %g1
                          <== NOT EXECUTED
      esc = RTEMS_INVALID_NUMBER;
                                    
      goto cleanup;
                                                  
    }
                                                                

                                                                     
    /* Check that begin and end are valid */
                         
    if (p->begin >= p->end) {
                                        
4003cb8c:	80 a1 00 01 	cmp  %g4, %g1
                                 <== NOT EXECUTED
4003cb90:	0a 80 00 18 	bcs  4003cbf0 <rtems_bdpart_write+0x114>
      <== NOT EXECUTED
4003cb94:	80 a6 00 01 	cmp  %i0, %g1
                                 <== NOT EXECUTED
4003cb98:	3a 80 00 17 	bcc,a   4003cbf4 <rtems_bdpart_write+0x118>
   <== NOT EXECUTED
4003cb9c:	ba 10 20 0a 	mov  0xa, %i5
                                 <== NOT EXECUTED
4003cba0:	82 06 a0 04 	add  %i2, 4, %g1
                              <== NOT EXECUTED
4003cba4:	b8 10 20 00 	clr  %i4
                                      <== NOT EXECUTED
  for (i = 0; i < count; ++i) {
                                      
4003cba8:	b8 07 20 01 	inc  %i4
                                      <== NOT EXECUTED
4003cbac:	80 a6 c0 1c 	cmp  %i3, %i4
                                 <== NOT EXECUTED
4003cbb0:	22 80 00 29 	be,a   4003cc54 <rtems_bdpart_write+0x178>
    <== NOT EXECUTED
4003cbb4:	c2 06 40 00 	ld  [ %i1 ], %g1
                              <== NOT EXECUTED
    if (p->begin >= disk_end || p->end > disk_end) {
                 
4003cbb8:	c4 00 60 2c 	ld  [ %g1 + 0x2c ], %g2
                       <== NOT EXECUTED
4003cbbc:	80 a0 80 04 	cmp  %g2, %g4
                                 <== NOT EXECUTED
4003cbc0:	1a 80 00 0d 	bcc  4003cbf4 <rtems_bdpart_write+0x118>
      <== NOT EXECUTED
4003cbc4:	ba 10 20 0a 	mov  0xa, %i5
                                 <== NOT EXECUTED
4003cbc8:	c6 00 60 30 	ld  [ %g1 + 0x30 ], %g3
                       <== NOT EXECUTED
    if (p->begin >= p->end) {
                                        
4003cbcc:	80 a0 80 03 	cmp  %g2, %g3
                                 <== NOT EXECUTED
4003cbd0:	1a 80 00 09 	bcc  4003cbf4 <rtems_bdpart_write+0x118>
      <== NOT EXECUTED
4003cbd4:	80 a1 00 03 	cmp  %g4, %g3
                                 <== NOT EXECUTED
4003cbd8:	0a 80 00 08 	bcs  4003cbf8 <rtems_bdpart_write+0x11c>
      <== NOT EXECUTED
4003cbdc:	d0 07 bf f8 	ld  [ %fp + -8 ], %o0
                         <== NOT EXECUTED
      esc = RTEMS_INVALID_NUMBER;
                                    
      goto cleanup;
                                                  
    }
                                                                

                                                                     
    /* Check that partitions do not overlap */
                       
    if (i > 0 && pt [i - 1].end > p->begin) {
                        
4003cbe0:	c6 00 40 00 	ld  [ %g1 ], %g3
                              <== NOT EXECUTED
4003cbe4:	80 a0 80 03 	cmp  %g2, %g3
                                 <== NOT EXECUTED
4003cbe8:	3a bf ff f0 	bcc,a   4003cba8 <rtems_bdpart_write+0xcc>
    <== NOT EXECUTED
4003cbec:	82 00 60 30 	add  %g1, 0x30, %g1
                           <== NOT EXECUTED
      esc = RTEMS_INVALID_NUMBER;
                                    
4003cbf0:	ba 10 20 0a 	mov  0xa, %i5
                                 <== NOT EXECUTED
    }
                                                                
  }
                                                                  

                                                                     
cleanup:
                                                             

                                                                     
  if (fd >= 0) {
                                                     
4003cbf4:	d0 07 bf f8 	ld  [ %fp + -8 ], %o0
                         <== NOT EXECUTED
4003cbf8:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
4003cbfc:	26 80 00 05 	bl,a   4003cc10 <rtems_bdpart_write+0x134>
    <== NOT EXECUTED
4003cc00:	d0 07 bf f0 	ld  [ %fp + -16 ], %o0
                        <== NOT EXECUTED
    close( fd);
                                                      
4003cc04:	7f ff 39 da 	call  4000b36c <close>
                        <== NOT EXECUTED
4003cc08:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  }
                                                                  

                                                                     
  if (block != NULL) {
                                               
4003cc0c:	d0 07 bf f0 	ld  [ %fp + -16 ], %o0
                        <== NOT EXECUTED
4003cc10:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
4003cc14:	02 80 00 04 	be  4003cc24 <rtems_bdpart_write+0x148>
       <== NOT EXECUTED
4003cc18:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
    rtems_bdbuf_sync( block);
                                        
4003cc1c:	7f ff 28 34 	call  40006cec <rtems_bdbuf_sync>
             <== NOT EXECUTED
4003cc20:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  }
                                                                  

                                                                     
  return esc;
                                                        
}
                                                                    
4003cc24:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4003cc28:	91 e8 00 1d 	restore  %g0, %i5, %o0
                        <== NOT EXECUTED
    && format->mbr.dos_compatibility;
                                
4003cc2c:	80 a0 60 00 	cmp  %g1, 0
                                   <== NOT EXECUTED
4003cc30:	02 bf ff b4 	be  4003cb00 <rtems_bdpart_write+0x24>
        <== NOT EXECUTED
4003cc34:	c0 27 bf f0 	clr  [ %fp + -16 ]
                            <== NOT EXECUTED
4003cc38:	a2 10 20 01 	mov  1, %l1
                                   <== NOT EXECUTED
  rtems_blkdev_bnum disk_end = 0;
                                    
4003cc3c:	c0 27 bf f4 	clr  [ %fp + -12 ]
                            <== NOT EXECUTED
    dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;
          
4003cc40:	10 bf ff b3 	b  4003cb0c <rtems_bdpart_write+0x30>
         <== NOT EXECUTED
4003cc44:	a0 10 20 3f 	mov  0x3f, %l0
                                <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;
                                    
4003cc48:	ba 10 20 09 	mov  9, %i5
                                   <== NOT EXECUTED
}
                                                                    
4003cc4c:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4003cc50:	91 e8 00 1d 	restore  %g0, %i5, %o0
                        <== NOT EXECUTED
  if (format->type != RTEMS_BDPART_FORMAT_MBR) {
                     
4003cc54:	80 a0 60 00 	cmp  %g1, 0
                                   <== NOT EXECUTED
4003cc58:	12 bf ff e7 	bne  4003cbf4 <rtems_bdpart_write+0x118>
      <== NOT EXECUTED
4003cc5c:	ba 10 20 18 	mov  0x18, %i5
                                <== NOT EXECUTED
  ppc = count <= 4 ? count : 3;
                                      
4003cc60:	80 a7 20 04 	cmp  %i4, 4
                                   <== NOT EXECUTED
4003cc64:	08 80 00 bb 	bleu  4003cf50 <rtems_bdpart_write+0x474>
     <== NOT EXECUTED
4003cc68:	80 a4 60 00 	cmp  %l1, 0
                                   <== NOT EXECUTED
  if (dos_compatibility && pt [0].begin != RTEMS_BDPART_MBR_CYLINDER_SIZE) {

4003cc6c:	12 80 00 c0 	bne  4003cf6c <rtems_bdpart_write+0x490>
      <== NOT EXECUTED
4003cc70:	80 a6 20 3f 	cmp  %i0, 0x3f
                                <== NOT EXECUTED
    if ((pt [i].begin - pt [i - 1].end) < record_space) {
            
4003cc74:	c2 06 a0 90 	ld  [ %i2 + 0x90 ], %g1
                       <== NOT EXECUTED
4003cc78:	c4 06 a0 64 	ld  [ %i2 + 0x64 ], %g2
                       <== NOT EXECUTED
4003cc7c:	82 20 40 02 	sub  %g1, %g2, %g1
                            <== NOT EXECUTED
4003cc80:	80 a4 00 01 	cmp  %l0, %g1
                                 <== NOT EXECUTED
4003cc84:	18 bf ff db 	bgu  4003cbf0 <rtems_bdpart_write+0x114>
      <== NOT EXECUTED
4003cc88:	ba 06 bf d4 	add  %i2, -44, %i5
                            <== NOT EXECUTED
4003cc8c:	89 2f 20 01 	sll  %i4, 1, %g4
                              <== NOT EXECUTED
4003cc90:	82 06 a0 94 	add  %i2, 0x94, %g1
                           <== NOT EXECUTED
4003cc94:	88 01 00 1c 	add  %g4, %i4, %g4
                            <== NOT EXECUTED
4003cc98:	85 29 20 04 	sll  %g4, 4, %g2
                              <== NOT EXECUTED
4003cc9c:	10 80 00 08 	b  4003ccbc <rtems_bdpart_write+0x1e0>
        <== NOT EXECUTED
4003cca0:	ba 07 40 02 	add  %i5, %g2, %i5
                            <== NOT EXECUTED
4003cca4:	c4 00 e0 2c 	ld  [ %g3 + 0x2c ], %g2
                       <== NOT EXECUTED
4003cca8:	c6 00 c0 00 	ld  [ %g3 ], %g3
                              <== NOT EXECUTED
4003ccac:	84 20 80 03 	sub  %g2, %g3, %g2
                            <== NOT EXECUTED
4003ccb0:	80 a0 80 10 	cmp  %g2, %l0
                                 <== NOT EXECUTED
4003ccb4:	0a bf ff cf 	bcs  4003cbf0 <rtems_bdpart_write+0x114>
      <== NOT EXECUTED
4003ccb8:	82 00 60 30 	add  %g1, 0x30, %g1
                           <== NOT EXECUTED
  for (i = ppc; i < count; ++i) {
                                    
4003ccbc:	80 a0 40 1d 	cmp  %g1, %i5
                                 <== NOT EXECUTED
4003ccc0:	12 bf ff f9 	bne  4003cca4 <rtems_bdpart_write+0x1c8>
      <== NOT EXECUTED
4003ccc4:	86 10 00 01 	mov  %g1, %g3
                                 <== NOT EXECUTED
4003ccc8:	b0 10 20 03 	mov  3, %i0
                                   <== NOT EXECUTED
4003cccc:	ba 06 a0 08 	add  %i2, 8, %i5
                              <== NOT EXECUTED
4003ccd0:	89 29 20 04 	sll  %g4, 4, %g4
                              <== NOT EXECUTED
4003ccd4:	b6 07 40 04 	add  %i5, %g4, %i3
                            <== NOT EXECUTED
    if (!rtems_bdpart_to_mbr_partition_type( p->type, &type)) {
      
4003ccd8:	90 10 00 1d 	mov  %i5, %o0
                                 <== NOT EXECUTED
    uint8_t type = 0;
                                                
4003ccdc:	c0 2f bf ef 	clrb  [ %fp + -17 ]
                           <== NOT EXECUTED
    if (!rtems_bdpart_to_mbr_partition_type( p->type, &type)) {
      
4003cce0:	7f ff fe 7f 	call  4003c6dc <rtems_bdpart_to_mbr_partition_type>
<== NOT EXECUTED
4003cce4:	92 07 bf ef 	add  %fp, -17, %o1
                            <== NOT EXECUTED
4003cce8:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
4003ccec:	22 bf ff c2 	be,a   4003cbf4 <rtems_bdpart_write+0x118>
    <== NOT EXECUTED
4003ccf0:	ba 10 20 04 	mov  4, %i5
                                   <== NOT EXECUTED
    if (p->flags > 0xffU) {
                                          
4003ccf4:	c2 07 60 20 	ld  [ %i5 + 0x20 ], %g1
                       <== NOT EXECUTED
4003ccf8:	80 a0 60 00 	cmp  %g1, 0
                                   <== NOT EXECUTED
4003ccfc:	32 bf ff be 	bne,a   4003cbf4 <rtems_bdpart_write+0x118>
   <== NOT EXECUTED
4003cd00:	ba 10 20 04 	mov  4, %i5
                                   <== NOT EXECUTED
4003cd04:	c2 07 60 24 	ld  [ %i5 + 0x24 ], %g1
                       <== NOT EXECUTED
4003cd08:	80 a0 60 ff 	cmp  %g1, 0xff
                                <== NOT EXECUTED
4003cd0c:	38 bf ff ba 	bgu,a   4003cbf4 <rtems_bdpart_write+0x118>
   <== NOT EXECUTED
4003cd10:	ba 10 20 04 	mov  4, %i5
                                   <== NOT EXECUTED
4003cd14:	ba 07 60 30 	add  %i5, 0x30, %i5
                           <== NOT EXECUTED
  for (i = 0; i < count; ++i) {
                                      
4003cd18:	80 a6 c0 1d 	cmp  %i3, %i5
                                 <== NOT EXECUTED
4003cd1c:	12 bf ff f0 	bne  4003ccdc <rtems_bdpart_write+0x200>
      <== NOT EXECUTED
4003cd20:	90 10 00 1d 	mov  %i5, %o0
                                 <== NOT EXECUTED
  sc = rtems_bdpart_new_record( dd, 0, &block);
                      
4003cd24:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0
                         <== NOT EXECUTED
4003cd28:	92 10 20 00 	clr  %o1
                                      <== NOT EXECUTED
4003cd2c:	7f ff ff 48 	call  4003ca4c <rtems_bdpart_new_record>
      <== NOT EXECUTED
4003cd30:	94 07 bf f0 	add  %fp, -16, %o2
                            <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL) {
                                      
4003cd34:	ba 92 20 00 	orcc  %o0, 0, %i5
                             <== NOT EXECUTED
4003cd38:	12 bf ff b0 	bne  4003cbf8 <rtems_bdpart_write+0x11c>
      <== NOT EXECUTED
4003cd3c:	d0 07 bf f8 	ld  [ %fp + -8 ], %o0
                         <== NOT EXECUTED
    block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
                  
4003cd40:	c6 07 bf f0 	ld  [ %fp + -16 ], %g3
                        <== NOT EXECUTED
  rtems_uint32_to_little_endian(
                                     
4003cd44:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1
                          <== NOT EXECUTED
    block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
                  
4003cd48:	c4 00 e0 1c 	ld  [ %g3 + 0x1c ], %g2
                       <== NOT EXECUTED
{
                                                                    
  int i;
                                                             

                                                                     
  for (i = 0; i < 4; ++i) {
                                          
    data [i] = (uint8_t) value;
                                      
    value >>= 8;
                                                     
4003cd4c:	89 30 60 10 	srl  %g1, 0x10, %g4
                           <== NOT EXECUTED
    data [i] = (uint8_t) value;
                                      
4003cd50:	c2 28 a1 b8 	stb  %g1, [ %g2 + 0x1b8 ]
                     <== NOT EXECUTED
    value >>= 8;
                                                     
4003cd54:	b7 30 60 08 	srl  %g1, 8, %i3
                              <== NOT EXECUTED
    data [i] = (uint8_t) value;
                                      
4003cd58:	c8 28 a1 ba 	stb  %g4, [ %g2 + 0x1ba ]
                     <== NOT EXECUTED
    value >>= 8;
                                                     
4003cd5c:	83 30 60 18 	srl  %g1, 0x18, %g1
                           <== NOT EXECUTED
    data [i] = (uint8_t) value;
                                      
4003cd60:	f6 28 a1 b9 	stb  %i3, [ %g2 + 0x1b9 ]
                     <== NOT EXECUTED
4003cd64:	9b 2e 20 04 	sll  %i0, 4, %o5
                              <== NOT EXECUTED
4003cd68:	c2 28 a1 bb 	stb  %g1, [ %g2 + 0x1bb ]
                     <== NOT EXECUTED
4003cd6c:	82 03 61 be 	add  %o5, 0x1be, %g1
                          <== NOT EXECUTED
  data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
            
4003cd70:	d4 00 e0 1c 	ld  [ %g3 + 0x1c ], %o2
                       <== NOT EXECUTED
4003cd74:	98 02 a1 be 	add  %o2, 0x1be, %o4
                          <== NOT EXECUTED
4003cd78:	88 10 00 1a 	mov  %i2, %g4
                                 <== NOT EXECUTED
4003cd7c:	94 02 80 01 	add  %o2, %g1, %o2
                            <== NOT EXECUTED
4003cd80:	82 10 00 0c 	mov  %o4, %g1
                                 <== NOT EXECUTED
    rtems_bdpart_write_mbr_partition(
                                
4003cd84:	c6 01 00 00 	ld  [ %g4 ], %g3
                              <== NOT EXECUTED
4003cd88:	c4 01 20 04 	ld  [ %g4 + 4 ], %g2
                          <== NOT EXECUTED
4003cd8c:	f2 09 20 08 	ldub  [ %g4 + 8 ], %i1
                        <== NOT EXECUTED
4003cd90:	f6 01 20 2c 	ld  [ %g4 + 0x2c ], %i3
                       <== NOT EXECUTED
4003cd94:	84 20 80 03 	sub  %g2, %g3, %g2
                            <== NOT EXECUTED
4003cd98:	c6 28 60 08 	stb  %g3, [ %g1 + 8 ]
                         <== NOT EXECUTED
    value >>= 8;
                                                     
4003cd9c:	9f 30 e0 10 	srl  %g3, 0x10, %o7
                           <== NOT EXECUTED
4003cda0:	97 30 e0 08 	srl  %g3, 8, %o3
                              <== NOT EXECUTED
4003cda4:	87 30 e0 18 	srl  %g3, 0x18, %g3
                           <== NOT EXECUTED
    data [i] = (uint8_t) value;
                                      
4003cda8:	c4 28 60 0c 	stb  %g2, [ %g1 + 0xc ]
                       <== NOT EXECUTED
    data += RTEMS_BDPART_MBR_TABLE_ENTRY_SIZE;
                       
4003cdac:	82 00 60 10 	add  %g1, 0x10, %g1
                           <== NOT EXECUTED
4003cdb0:	de 28 7f fa 	stb  %o7, [ %g1 + -6 ]
                        <== NOT EXECUTED
    value >>= 8;
                                                     
4003cdb4:	9f 30 a0 08 	srl  %g2, 8, %o7
                              <== NOT EXECUTED
    data [i] = (uint8_t) value;
                                      
4003cdb8:	c6 28 7f fb 	stb  %g3, [ %g1 + -5 ]
                        <== NOT EXECUTED
    value >>= 8;
                                                     
4003cdbc:	87 30 a0 10 	srl  %g2, 0x10, %g3
                           <== NOT EXECUTED
    data [i] = (uint8_t) value;
                                      
4003cdc0:	d6 28 7f f9 	stb  %o3, [ %g1 + -7 ]
                        <== NOT EXECUTED
    value >>= 8;
                                                     
4003cdc4:	85 30 a0 18 	srl  %g2, 0x18, %g2
                           <== NOT EXECUTED
    data [i] = (uint8_t) value;
                                      
4003cdc8:	de 28 7f fd 	stb  %o7, [ %g1 + -3 ]
                        <== NOT EXECUTED
4003cdcc:	88 01 20 30 	add  %g4, 0x30, %g4
                           <== NOT EXECUTED
4003cdd0:	c6 28 7f fe 	stb  %g3, [ %g1 + -2 ]
                        <== NOT EXECUTED
4003cdd4:	c4 28 7f ff 	stb  %g2, [ %g1 + -1 ]
                        <== NOT EXECUTED
  for (i = 0; i < ppc; ++i) {
                                        
4003cdd8:	80 a0 40 0a 	cmp  %g1, %o2
                                 <== NOT EXECUTED
  data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
                        
4003cddc:	f2 28 7f f4 	stb  %i1, [ %g1 + -12 ]
                       <== NOT EXECUTED
  for (i = 0; i < ppc; ++i) {
                                        
4003cde0:	12 bf ff e9 	bne  4003cd84 <rtems_bdpart_write+0x2a8>
      <== NOT EXECUTED
4003cde4:	f6 28 7f f0 	stb  %i3, [ %g1 + -16 ]
                       <== NOT EXECUTED
  if (ppc != count) {
                                                
4003cde8:	80 a7 00 18 	cmp  %i4, %i0
                                 <== NOT EXECUTED
4003cdec:	02 bf ff 82 	be  4003cbf4 <rtems_bdpart_write+0x118>
       <== NOT EXECUTED
4003cdf0:	84 03 00 0d 	add  %o4, %o5, %g2
                            <== NOT EXECUTED
    rtems_blkdev_bnum ep_begin = pt [ppc].begin - record_space;
      
4003cdf4:	83 2e 20 01 	sll  %i0, 1, %g1
                              <== NOT EXECUTED
4003cdf8:	82 00 40 18 	add  %g1, %i0, %g1
                            <== NOT EXECUTED
4003cdfc:	83 28 60 04 	sll  %g1, 4, %g1
                              <== NOT EXECUTED
4003ce00:	e4 06 80 01 	ld  [ %i2 + %g1 ], %l2
                        <== NOT EXECUTED
4003ce04:	a4 24 80 10 	sub  %l2, %l0, %l2
                            <== NOT EXECUTED
    value >>= 8;
                                                     
4003ce08:	89 34 a0 08 	srl  %l2, 8, %g4
                              <== NOT EXECUTED
    rtems_bdpart_write_mbr_partition(
                                
4003ce0c:	c6 07 bf f4 	ld  [ %fp + -12 ], %g3
                        <== NOT EXECUTED
4003ce10:	b7 34 a0 10 	srl  %l2, 0x10, %i3
                           <== NOT EXECUTED
    data [i] = (uint8_t) value;
                                      
4003ce14:	c8 28 a0 09 	stb  %g4, [ %g2 + 9 ]
                         <== NOT EXECUTED
    value >>= 8;
                                                     
4003ce18:	89 34 a0 18 	srl  %l2, 0x18, %g4
                           <== NOT EXECUTED
4003ce1c:	86 20 c0 12 	sub  %g3, %l2, %g3
                            <== NOT EXECUTED
    data [i] = (uint8_t) value;
                                      
4003ce20:	f6 28 a0 0a 	stb  %i3, [ %g2 + 0xa ]
                       <== NOT EXECUTED
    value >>= 8;
                                                     
4003ce24:	b7 30 e0 08 	srl  %g3, 8, %i3
                              <== NOT EXECUTED
    data [i] = (uint8_t) value;
                                      
4003ce28:	c8 28 a0 0b 	stb  %g4, [ %g2 + 0xb ]
                       <== NOT EXECUTED
    value >>= 8;
                                                     
4003ce2c:	89 30 e0 10 	srl  %g3, 0x10, %g4
                           <== NOT EXECUTED
    data [i] = (uint8_t) value;
                                      
4003ce30:	c6 28 a0 0c 	stb  %g3, [ %g2 + 0xc ]
                       <== NOT EXECUTED
    value >>= 8;
                                                     
4003ce34:	87 30 e0 18 	srl  %g3, 0x18, %g3
                           <== NOT EXECUTED
    data [i] = (uint8_t) value;
                                      
4003ce38:	f6 28 a0 0d 	stb  %i3, [ %g2 + 0xd ]
                       <== NOT EXECUTED
    rtems_blkdev_bnum ep_begin = pt [ppc].begin - record_space;
      
4003ce3c:	b6 06 80 01 	add  %i2, %g1, %i3
                            <== NOT EXECUTED
4003ce40:	c6 28 a0 0f 	stb  %g3, [ %g2 + 0xf ]
                       <== NOT EXECUTED
  data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
                        
4003ce44:	86 10 20 05 	mov  5, %g3
                                   <== NOT EXECUTED
4003ce48:	e4 28 a0 08 	stb  %l2, [ %g2 + 8 ]
                         <== NOT EXECUTED
4003ce4c:	c8 28 a0 0e 	stb  %g4, [ %g2 + 0xe ]
                       <== NOT EXECUTED
4003ce50:	c6 28 a0 04 	stb  %g3, [ %g2 + 4 ]
                         <== NOT EXECUTED
    for (i = ppc; i < count; ++i) {
                                  
4003ce54:	08 bf ff 68 	bleu  4003cbf4 <rtems_bdpart_write+0x118>
     <== NOT EXECUTED
4003ce58:	c0 2b 00 0d 	clrb  [ %o4 + %o5 ]
                           <== NOT EXECUTED
4003ce5c:	82 00 60 30 	add  %g1, 0x30, %g1
                           <== NOT EXECUTED
4003ce60:	a2 10 00 18 	mov  %i0, %l1
                                 <== NOT EXECUTED
4003ce64:	b4 06 80 01 	add  %i2, %g1, %i2
                            <== NOT EXECUTED
  data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
                        
4003ce68:	b2 10 20 05 	mov  5, %i1
                                   <== NOT EXECUTED
      ebr = p->begin - record_space;
                                 
4003ce6c:	d2 06 c0 00 	ld  [ %i3 ], %o1
                              <== NOT EXECUTED
      sc = rtems_bdpart_new_record( dd, ebr, &block);
                
4003ce70:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0
                         <== NOT EXECUTED
4003ce74:	94 07 bf f0 	add  %fp, -16, %o2
                            <== NOT EXECUTED
4003ce78:	7f ff fe f5 	call  4003ca4c <rtems_bdpart_new_record>
      <== NOT EXECUTED
4003ce7c:	92 22 40 10 	sub  %o1, %l0, %o1
                            <== NOT EXECUTED
      if (sc != RTEMS_SUCCESSFUL) {
                                  
4003ce80:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
4003ce84:	12 80 00 3e 	bne  4003cf7c <rtems_bdpart_write+0x4a0>
      <== NOT EXECUTED
4003ce88:	de 07 bf f0 	ld  [ %fp + -16 ], %o7
                        <== NOT EXECUTED
      rtems_bdpart_write_mbr_partition(
                              
4003ce8c:	da 06 c0 00 	ld  [ %i3 ], %o5
                              <== NOT EXECUTED
4003ce90:	c4 06 e0 04 	ld  [ %i3 + 4 ], %g2
                          <== NOT EXECUTED
4003ce94:	c8 0e e0 08 	ldub  [ %i3 + 8 ], %g4
                        <== NOT EXECUTED
4003ce98:	c6 06 e0 2c 	ld  [ %i3 + 0x2c ], %g3
                       <== NOT EXECUTED
        block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,
             
4003ce9c:	c2 03 e0 1c 	ld  [ %o7 + 0x1c ], %g1
                       <== NOT EXECUTED
      rtems_bdpart_write_mbr_partition(
                              
4003cea0:	84 20 80 0d 	sub  %g2, %o5, %g2
                            <== NOT EXECUTED
4003cea4:	e0 28 61 c6 	stb  %l0, [ %g1 + 0x1c6 ]
                     <== NOT EXECUTED
    value >>= 8;
                                                     
4003cea8:	97 30 a0 08 	srl  %g2, 8, %o3
                              <== NOT EXECUTED
4003ceac:	99 30 a0 10 	srl  %g2, 0x10, %o4
                           <== NOT EXECUTED
4003ceb0:	9b 30 a0 18 	srl  %g2, 0x18, %o5
                           <== NOT EXECUTED
    data [i] = (uint8_t) value;
                                      
4003ceb4:	c0 28 61 c7 	clrb  [ %g1 + 0x1c7 ]
                         <== NOT EXECUTED
    for (i = ppc; i < count; ++i) {
                                  
4003ceb8:	a2 04 60 01 	inc  %l1
                                      <== NOT EXECUTED
4003cebc:	c0 28 61 c8 	clrb  [ %g1 + 0x1c8 ]
                         <== NOT EXECUTED
4003cec0:	80 a4 40 1c 	cmp  %l1, %i4
                                 <== NOT EXECUTED
4003cec4:	c0 28 61 c9 	clrb  [ %g1 + 0x1c9 ]
                         <== NOT EXECUTED
4003cec8:	b6 06 e0 30 	add  %i3, 0x30, %i3
                           <== NOT EXECUTED
4003cecc:	c4 28 61 ca 	stb  %g2, [ %g1 + 0x1ca ]
                     <== NOT EXECUTED
4003ced0:	d6 28 61 cb 	stb  %o3, [ %g1 + 0x1cb ]
                     <== NOT EXECUTED
4003ced4:	d8 28 61 cc 	stb  %o4, [ %g1 + 0x1cc ]
                     <== NOT EXECUTED
4003ced8:	da 28 61 cd 	stb  %o5, [ %g1 + 0x1cd ]
                     <== NOT EXECUTED
  data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
                        
4003cedc:	c8 28 61 c2 	stb  %g4, [ %g1 + 0x1c2 ]
                     <== NOT EXECUTED
    for (i = ppc; i < count; ++i) {
                                  
4003cee0:	02 bf ff 45 	be  4003cbf4 <rtems_bdpart_write+0x118>
       <== NOT EXECUTED
4003cee4:	c6 28 61 be 	stb  %g3, [ %g1 + 0x1be ]
                     <== NOT EXECUTED
4003cee8:	c4 06 80 00 	ld  [ %i2 ], %g2
                              <== NOT EXECUTED
4003ceec:	88 20 80 10 	sub  %g2, %l0, %g4
                            <== NOT EXECUTED
      if (i > ppc) {
                                                 
4003cef0:	80 a4 40 18 	cmp  %l1, %i0
                                 <== NOT EXECUTED
        rtems_bdpart_write_mbr_partition(
                            
4003cef4:	86 21 00 12 	sub  %g4, %l2, %g3
                            <== NOT EXECUTED
    value >>= 8;
                                                     
4003cef8:	97 30 e0 08 	srl  %g3, 8, %o3
                              <== NOT EXECUTED
4003cefc:	99 30 e0 10 	srl  %g3, 0x10, %o4
                           <== NOT EXECUTED
      if (i > ppc) {
                                                 
4003cf00:	08 80 00 12 	bleu  4003cf48 <rtems_bdpart_write+0x46c>
     <== NOT EXECUTED
4003cf04:	9b 30 e0 18 	srl  %g3, 0x18, %o5
                           <== NOT EXECUTED
          block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1,
           
4003cf08:	c2 03 e0 1c 	ld  [ %o7 + 0x1c ], %g1
                       <== NOT EXECUTED
        rtems_bdpart_write_mbr_partition(
                            
4003cf0c:	c4 07 bf f4 	ld  [ %fp + -12 ], %g2
                        <== NOT EXECUTED
4003cf10:	84 20 80 04 	sub  %g2, %g4, %g2
                            <== NOT EXECUTED
    data [i] = (uint8_t) value;
                                      
4003cf14:	c6 28 61 d6 	stb  %g3, [ %g1 + 0x1d6 ]
                     <== NOT EXECUTED
    value >>= 8;
                                                     
4003cf18:	9f 30 a0 08 	srl  %g2, 8, %o7
                              <== NOT EXECUTED
4003cf1c:	89 30 a0 10 	srl  %g2, 0x10, %g4
                           <== NOT EXECUTED
4003cf20:	87 30 a0 18 	srl  %g2, 0x18, %g3
                           <== NOT EXECUTED
    data [i] = (uint8_t) value;
                                      
4003cf24:	d6 28 61 d7 	stb  %o3, [ %g1 + 0x1d7 ]
                     <== NOT EXECUTED
4003cf28:	d8 28 61 d8 	stb  %o4, [ %g1 + 0x1d8 ]
                     <== NOT EXECUTED
4003cf2c:	da 28 61 d9 	stb  %o5, [ %g1 + 0x1d9 ]
                     <== NOT EXECUTED
4003cf30:	c4 28 61 da 	stb  %g2, [ %g1 + 0x1da ]
                     <== NOT EXECUTED
4003cf34:	de 28 61 db 	stb  %o7, [ %g1 + 0x1db ]
                     <== NOT EXECUTED
4003cf38:	c8 28 61 dc 	stb  %g4, [ %g1 + 0x1dc ]
                     <== NOT EXECUTED
4003cf3c:	c6 28 61 dd 	stb  %g3, [ %g1 + 0x1dd ]
                     <== NOT EXECUTED
  data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
                        
4003cf40:	f2 28 61 d2 	stb  %i1, [ %g1 + 0x1d2 ]
                     <== NOT EXECUTED
  data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;
                      
4003cf44:	c0 28 61 ce 	clrb  [ %g1 + 0x1ce ]
                         <== NOT EXECUTED
4003cf48:	10 bf ff c9 	b  4003ce6c <rtems_bdpart_write+0x390>
        <== NOT EXECUTED
4003cf4c:	b4 06 a0 30 	add  %i2, 0x30, %i2
                           <== NOT EXECUTED
  if (dos_compatibility && pt [0].begin != RTEMS_BDPART_MBR_CYLINDER_SIZE) {

4003cf50:	02 80 00 04 	be  4003cf60 <rtems_bdpart_write+0x484>
       <== NOT EXECUTED
4003cf54:	80 a6 20 3f 	cmp  %i0, 0x3f
                                <== NOT EXECUTED
4003cf58:	12 bf ff 27 	bne  4003cbf4 <rtems_bdpart_write+0x118>
      <== NOT EXECUTED
4003cf5c:	ba 10 20 0a 	mov  0xa, %i5
                                 <== NOT EXECUTED
4003cf60:	b0 10 00 1c 	mov  %i4, %i0
                                 <== NOT EXECUTED
4003cf64:	10 bf ff 5a 	b  4003cccc <rtems_bdpart_write+0x1f0>
        <== NOT EXECUTED
4003cf68:	88 5f 20 03 	smul  %i4, 3, %g4
                             <== NOT EXECUTED
4003cf6c:	02 bf ff 42 	be  4003cc74 <rtems_bdpart_write+0x198>
       <== NOT EXECUTED
4003cf70:	ba 10 20 0a 	mov  0xa, %i5
                                 <== NOT EXECUTED
4003cf74:	10 bf ff 21 	b  4003cbf8 <rtems_bdpart_write+0x11c>
        <== NOT EXECUTED
4003cf78:	d0 07 bf f8 	ld  [ %fp + -8 ], %o0
                         <== NOT EXECUTED
      sc = rtems_bdpart_new_record( dd, ebr, &block);
                
4003cf7c:	10 bf ff 1e 	b  4003cbf4 <rtems_bdpart_write+0x118>
        <== NOT EXECUTED
4003cf80:	ba 10 00 08 	mov  %o0, %i5
                                 <== NOT EXECUTED

                                                                     
===============================================================================
400075f8 <rtems_blkdev_create_partition>:
                            
  const char *partition,
                                             
  const char *parent_block_device,
                                   
  rtems_blkdev_bnum media_block_begin,
                               
  rtems_blkdev_bnum media_block_count
                                
)
                                                                    
{
                                                                    
400075f8:	9d e3 bf 38 	save  %sp, -200, %sp
                          <== NOT EXECUTED
  rtems_status_code sc = RTEMS_SUCCESSFUL;
                           
  int fd = open(parent_block_device, O_RDWR);
                        
400075fc:	92 10 20 02 	mov  2, %o1
                                   <== NOT EXECUTED
40007600:	90 10 00 19 	mov  %i1, %o0
                                 <== NOT EXECUTED
40007604:	40 00 13 46 	call  4000c31c <open>
                         <== NOT EXECUTED
40007608:	ba 10 20 04 	mov  4, %i5
                                   <== NOT EXECUTED

                                                                     
  if (fd >= 0) {
                                                     
4000760c:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
40007610:	06 80 00 0f 	bl  4000764c <rtems_blkdev_create_partition+0x54>
<== NOT EXECUTED
40007614:	b8 10 00 08 	mov  %o0, %i4
                                 <== NOT EXECUTED
    int rv;
                                                          
    struct stat st;
                                                  

                                                                     
    rv = fstat(fd, &st);
                                             
40007618:	40 00 10 30 	call  4000b6d8 <fstat>
                        <== NOT EXECUTED
4000761c:	92 07 bf a0 	add  %fp, -96, %o1
                            <== NOT EXECUTED
    if (rv == 0 && S_ISBLK(st.st_mode)) {
                            
40007620:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
40007624:	12 80 00 0c 	bne  40007654 <rtems_blkdev_create_partition+0x5c>
<== NOT EXECUTED
40007628:	03 00 00 3c 	sethi  %hi(0xf000), %g1
                       <== NOT EXECUTED
4000762c:	f2 07 bf ac 	ld  [ %fp + -84 ], %i1
                        <== NOT EXECUTED
40007630:	b2 0e 40 01 	and  %i1, %g1, %i1
                            <== NOT EXECUTED
40007634:	03 00 00 18 	sethi  %hi(0x6000), %g1
                       <== NOT EXECUTED
40007638:	80 a6 40 01 	cmp  %i1, %g1
                                 <== NOT EXECUTED
4000763c:	02 80 00 08 	be  4000765c <rtems_blkdev_create_partition+0x64>
<== NOT EXECUTED
40007640:	ba 10 20 15 	mov  0x15, %i5
                                <== NOT EXECUTED
    } else {
                                                         
      sc = RTEMS_INVALID_NODE;
                                       
    }
                                                                

                                                                     
    if (sc != RTEMS_SUCCESSFUL) {
                                    
      close(fd);
                                                     
40007644:	40 00 0f 4a 	call  4000b36c <close>
                        <== NOT EXECUTED
40007648:	90 10 00 1c 	mov  %i4, %o0
                                 <== NOT EXECUTED
  } else {
                                                           
    sc = RTEMS_INVALID_ID;
                                           
  }
                                                                  

                                                                     
  return sc;
                                                         
}
                                                                    
4000764c:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40007650:	91 e8 00 1d 	restore  %g0, %i5, %o0
                        <== NOT EXECUTED
      sc = RTEMS_INVALID_NODE;
                                       
40007654:	10 bf ff fc 	b  40007644 <rtems_blkdev_create_partition+0x4c>
<== NOT EXECUTED
40007658:	ba 10 20 15 	mov  0x15, %i5
                                <== NOT EXECUTED
static inline int rtems_disk_fd_get_disk_device(
                     
  int fd,
                                                            
  rtems_disk_device **dd_ptr
                                         
)
                                                                    
{
                                                                    
  return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
                  
4000765c:	94 07 bf 9c 	add  %fp, -100, %o2
                           <== NOT EXECUTED
40007660:	90 10 00 1c 	mov  %i4, %o0
                                 <== NOT EXECUTED
40007664:	13 10 01 10 	sethi  %hi(0x40044000), %o1
                   <== NOT EXECUTED
        sc = RTEMS_NOT_IMPLEMENTED;
                                  
40007668:	ba 10 20 18 	mov  0x18, %i5
                                <== NOT EXECUTED
4000766c:	40 00 10 82 	call  4000b874 <ioctl>
                        <== NOT EXECUTED
40007670:	92 12 62 09 	or  %o1, 0x209, %o1
                           <== NOT EXECUTED
      if (rv == 0) {
                                                 
40007674:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
40007678:	12 bf ff f3 	bne  40007644 <rtems_blkdev_create_partition+0x4c>
<== NOT EXECUTED
4000767c:	90 10 20 80 	mov  0x80, %o0
                                <== NOT EXECUTED
        rtems_blkdev_imfs_context *ctx = malloc(sizeof(*ctx));
       
40007680:	40 00 11 c3 	call  4000bd8c <malloc>
                       <== NOT EXECUTED
40007684:	ba 10 20 1a 	mov  0x1a, %i5
                                <== NOT EXECUTED
        if (ctx != NULL) {
                                           
40007688:	a0 92 20 00 	orcc  %o0, 0, %l0
                             <== NOT EXECUTED
4000768c:	02 bf ff ee 	be  40007644 <rtems_blkdev_create_partition+0x4c>
<== NOT EXECUTED
40007690:	d2 07 bf 9c 	ld  [ %fp + -100 ], %o1
                       <== NOT EXECUTED
          sc = rtems_disk_init_log(
                                  
40007694:	96 10 00 1b 	mov  %i3, %o3
                                 <== NOT EXECUTED
40007698:	40 00 02 e0 	call  40008218 <rtems_disk_init_log>
          <== NOT EXECUTED
4000769c:	94 10 00 1a 	mov  %i2, %o2
                                 <== NOT EXECUTED
          if (sc == RTEMS_SUCCESSFUL) {
                              
400076a0:	ba 92 20 00 	orcc  %o0, 0, %i5
                             <== NOT EXECUTED
400076a4:	12 80 00 0e 	bne  400076dc <rtems_blkdev_create_partition+0xe4>
<== NOT EXECUTED
400076a8:	96 10 00 10 	mov  %l0, %o3
                                 <== NOT EXECUTED
            ctx->fd = fd;
                                            
400076ac:	f8 24 20 78 	st  %i4, [ %l0 + 0x78 ]
                       <== NOT EXECUTED
            rv = IMFS_make_generic_node(
                             
400076b0:	92 16 61 ff 	or  %i1, 0x1ff, %o1
                           <== NOT EXECUTED
400076b4:	15 10 01 f2 	sethi  %hi(0x4007c800), %o2
                   <== NOT EXECUTED
400076b8:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
400076bc:	40 00 06 e2 	call  40009244 <IMFS_make_generic_node>
       <== NOT EXECUTED
400076c0:	94 12 a1 88 	or  %o2, 0x188, %o2
                           <== NOT EXECUTED
            if (rv != 0) {
                                           
400076c4:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
400076c8:	02 bf ff e1 	be  4000764c <rtems_blkdev_create_partition+0x54>
<== NOT EXECUTED
400076cc:	90 10 00 10 	mov  %l0, %o0
                                 <== NOT EXECUTED
              free(ctx);
                                             
400076d0:	40 00 0f ec 	call  4000b680 <free>
                         <== NOT EXECUTED
400076d4:	ba 10 20 0d 	mov  0xd, %i5
                                 <== NOT EXECUTED
400076d8:	30 bf ff db 	b,a   40007644 <rtems_blkdev_create_partition+0x4c>
<== NOT EXECUTED
            free(ctx);
                                               
400076dc:	40 00 0f e9 	call  4000b680 <free>
                         <== NOT EXECUTED
400076e0:	90 10 00 10 	mov  %l0, %o0
                                 <== NOT EXECUTED
400076e4:	30 bf ff d8 	b,a   40007644 <rtems_blkdev_create_partition+0x4c>
<== NOT EXECUTED

                                                                     
===============================================================================
40007910 <rtems_blkdev_generic_close>:
                               
rtems_device_driver
                                                  
rtems_blkdev_generic_close(
                                          
    rtems_device_major_number major RTEMS_UNUSED,
                    
    rtems_device_minor_number minor RTEMS_UNUSED,
                    
    void                    * arg)
                                   
{
                                                                    
40007910:	9d e3 bf a0 	save  %sp, -96, %sp
                           <== NOT EXECUTED
  rtems_libio_open_close_args_t *oc = arg;
                           
  rtems_libio_t *iop = oc->iop;
                                      
  rtems_disk_device *dd = iop->data1;
                                
40007914:	c2 06 80 00 	ld  [ %i2 ], %g1
                              <== NOT EXECUTED

                                                                     
  rtems_disk_release(dd);
                                            
40007918:	40 00 03 dd 	call  4000888c <rtems_disk_release>
           <== NOT EXECUTED
4000791c:	d0 00 60 28 	ld  [ %g1 + 0x28 ], %o0
                       <== NOT EXECUTED

                                                                     
  return RTEMS_SUCCESSFUL;
                                           
}
                                                                    
40007920:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40007924:	91 e8 20 00 	restore  %g0, 0, %o0
                          <== NOT EXECUTED

                                                                     
===============================================================================
40007928 <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)
                                   
{
                                                                    
40007928:	9d e3 bf a0 	save  %sp, -96, %sp
                           <== NOT EXECUTED
    rtems_libio_ioctl_args_t *args = arg;
                            
    rtems_libio_t *iop = args->iop;
                                  
    rtems_disk_device *dd = iop->data1;
                              
4000792c:	c2 06 80 00 	ld  [ %i2 ], %g1
                              <== NOT EXECUTED

                                                                     
    if (args->command != RTEMS_BLKIO_REQUEST)
                        
40007930:	d2 06 a0 04 	ld  [ %i2 + 4 ], %o1
                          <== NOT EXECUTED
    rtems_disk_device *dd = iop->data1;
                              
40007934:	d0 00 60 28 	ld  [ %g1 + 0x28 ], %o0
                       <== NOT EXECUTED
    if (args->command != RTEMS_BLKIO_REQUEST)
                        
40007938:	03 30 06 10 	sethi  %hi(0xc0184000), %g1
                   <== NOT EXECUTED
4000793c:	82 10 62 01 	or  %g1, 0x201, %g1	! c0184201 <RAM_END+0x7fd84201>
<== NOT EXECUTED
40007940:	80 a2 40 01 	cmp  %o1, %g1
                                 <== NOT EXECUTED
40007944:	02 80 00 08 	be  40007964 <rtems_blkdev_generic_ioctl+0x3c>
<== NOT EXECUTED
40007948:	82 10 3f ff 	mov  -1, %g1
                                  <== NOT EXECUTED
    {
                                                                
        args->ioctl_return = dd->ioctl(dd,
                           
4000794c:	c2 02 20 38 	ld  [ %o0 + 0x38 ], %g1
                       <== NOT EXECUTED
40007950:	9f c0 40 00 	call  %g1
                                     <== NOT EXECUTED
40007954:	d4 06 a0 08 	ld  [ %i2 + 8 ], %o2
                          <== NOT EXECUTED
40007958:	d0 26 a0 0c 	st  %o0, [ %i2 + 0xc ]
                        <== NOT EXECUTED
         */
                                                          
        args->ioctl_return = -1;
                                     
    }
                                                                

                                                                     
    return RTEMS_SUCCESSFUL;
                                         
}
                                                                    
4000795c:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40007960:	91 e8 20 00 	restore  %g0, 0, %o0
                          <== NOT EXECUTED
        args->ioctl_return = -1;
                                     
40007964:	10 bf ff fe 	b  4000795c <rtems_blkdev_generic_ioctl+0x34>
 <== NOT EXECUTED
40007968:	c2 26 a0 0c 	st  %g1, [ %i2 + 0xc ]
                        <== NOT EXECUTED

                                                                     
===============================================================================
400078e4 <rtems_blkdev_generic_open>:
                                
rtems_device_driver
                                                  
rtems_blkdev_generic_open(
                                           
    rtems_device_major_number major,
                                 
    rtems_device_minor_number minor,
                                 
    void                    * arg)
                                   
{
                                                                    
400078e4:	9d e3 bf a0 	save  %sp, -96, %sp
                           <== NOT EXECUTED
  rtems_libio_open_close_args_t *oc = arg;
                           
  rtems_libio_t *iop = oc->iop;
                                      
400078e8:	fa 06 80 00 	ld  [ %i2 ], %i5
                              <== NOT EXECUTED
  dev_t dev = rtems_filesystem_make_dev_t(major, minor);
             
  rtems_disk_device *dd = rtems_disk_obtain(dev);
                    
400078ec:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
400078f0:	40 00 03 c4 	call  40008800 <rtems_disk_obtain>
            <== NOT EXECUTED
400078f4:	92 10 00 19 	mov  %i1, %o1
                                 <== NOT EXECUTED
  iop->data1 = dd;
                                                   

                                                                     
  if (dd != NULL)
                                                    
    return RTEMS_SUCCESSFUL;
                                         
  else
                                                               
    return RTEMS_UNSATISFIED;
                                        
400078f8:	80 a0 00 08 	cmp  %g0, %o0
                                 <== NOT EXECUTED
  iop->data1 = dd;
                                                   
400078fc:	d0 27 60 28 	st  %o0, [ %i5 + 0x28 ]
                       <== NOT EXECUTED
    return RTEMS_UNSATISFIED;
                                        
40007900:	b0 60 20 00 	subx  %g0, 0, %i0
                             <== NOT EXECUTED
40007904:	b0 0e 3f f3 	and  %i0, -13, %i0
                            <== NOT EXECUTED
}
                                                                    
40007908:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4000790c:	91 ee 20 0d 	restore  %i0, 0xd, %o0
                        <== NOT EXECUTED

                                                                     
===============================================================================
400076e8 <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)
                                   
{
                                                                    
400076e8:	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;
                              
400076ec:	c2 06 80 00 	ld  [ %i2 ], %g1
                              <== NOT EXECUTED
400076f0:	e4 00 60 28 	ld  [ %g1 + 0x28 ], %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);

400076f4:	f8 1e a0 08 	ldd  [ %i2 + 8 ], %i4
                         <== NOT EXECUTED
    uint32_t block_size = dd->block_size;
                            
400076f8:	e2 04 a0 24 	ld  [ %l2 + 0x24 ], %l1
                       <== NOT EXECUTED
    rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);

400076fc:	94 10 20 00 	clr  %o2
                                      <== NOT EXECUTED
40007700:	96 10 00 11 	mov  %l1, %o3
                                 <== NOT EXECUTED
40007704:	90 10 00 1c 	mov  %i4, %o0
                                 <== NOT EXECUTED
40007708:	40 01 c9 0f 	call  40079b44 <__divdi3>
                     <== NOT EXECUTED
4000770c:	92 10 00 1d 	mov  %i5, %o1
                                 <== NOT EXECUTED
    uint32_t blkofs = (uint32_t) (args->offset % block_size);
        
40007710:	90 10 00 1c 	mov  %i4, %o0
                                 <== NOT EXECUTED
    rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);

40007714:	b2 10 00 09 	mov  %o1, %i1
                                 <== NOT EXECUTED
    uint32_t blkofs = (uint32_t) (args->offset % block_size);
        
40007718:	94 10 20 00 	clr  %o2
                                      <== NOT EXECUTED
4000771c:	96 10 00 11 	mov  %l1, %o3
                                 <== NOT EXECUTED
40007720:	40 01 c9 94 	call  40079d70 <__moddi3>
                     <== NOT EXECUTED
40007724:	92 10 00 1d 	mov  %i5, %o1
                                 <== NOT EXECUTED

                                                                     
    args->bytes_moved = 0;
                                           
40007728:	c0 26 a0 1c 	clr  [ %i2 + 0x1c ]
                           <== NOT EXECUTED
    uint32_t blkofs = (uint32_t) (args->offset % block_size);
        
4000772c:	a0 10 00 09 	mov  %o1, %l0
                                 <== NOT EXECUTED
    uint32_t count = args->count;
                                    
40007730:	f8 06 a0 14 	ld  [ %i2 + 0x14 ], %i4
                       <== NOT EXECUTED

                                                                     
    while (count > 0)
                                                
40007734:	80 a7 20 00 	cmp  %i4, 0
                                   <== NOT EXECUTED
40007738:	12 80 00 1a 	bne  400077a0 <rtems_blkdev_generic_read+0xb8>
<== NOT EXECUTED
4000773c:	f6 06 a0 10 	ld  [ %i2 + 0x10 ], %i3
                       <== NOT EXECUTED
{
                                                                    
40007740:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40007744:	91 e8 20 00 	restore  %g0, 0, %o0
                          <== NOT EXECUTED
        uint32_t            copy;
                                    

                                                                     
        rc = rtems_bdbuf_read(dd, block, &diskbuf);
                  
        if (rc != RTEMS_SUCCESSFUL)
                                  
            break;
                                                   
        copy = block_size - blkofs;
                                  
40007748:	ba 24 40 10 	sub  %l1, %l0, %i5
                            <== NOT EXECUTED
4000774c:	80 a7 40 1c 	cmp  %i5, %i4
                                 <== NOT EXECUTED
40007750:	38 80 00 02 	bgu,a   40007758 <rtems_blkdev_generic_read+0x70>
<== NOT EXECUTED
40007754:	ba 10 00 1c 	mov  %i4, %i5
                                 <== NOT EXECUTED
        if (copy > count)
                                            
            copy = count;
                                            
        memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
         
40007758:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1
                         <== NOT EXECUTED
4000775c:	d2 00 60 1c 	ld  [ %g1 + 0x1c ], %o1
                       <== NOT EXECUTED
40007760:	92 02 40 10 	add  %o1, %l0, %o1
                            <== NOT EXECUTED
40007764:	40 01 66 1b 	call  40060fd0 <memcpy>
                       <== NOT EXECUTED
40007768:	94 10 00 1d 	mov  %i5, %o2
                                 <== NOT EXECUTED
        rc = rtems_bdbuf_release(diskbuf);
                           
4000776c:	7f ff fc f8 	call  40006b4c <rtems_bdbuf_release>
          <== NOT EXECUTED
40007770:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0
                         <== NOT EXECUTED
        args->bytes_moved += copy;
                                   
40007774:	c2 06 a0 1c 	ld  [ %i2 + 0x1c ], %g1
                       <== NOT EXECUTED
40007778:	82 00 40 1d 	add  %g1, %i5, %g1
                            <== NOT EXECUTED
4000777c:	c2 26 a0 1c 	st  %g1, [ %i2 + 0x1c ]
                       <== NOT EXECUTED
        if (rc != RTEMS_SUCCESSFUL)
                                  
40007780:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
40007784:	12 80 00 0f 	bne  400077c0 <rtems_blkdev_generic_read+0xd8>
<== NOT EXECUTED
40007788:	b0 10 00 08 	mov  %o0, %i0
                                 <== NOT EXECUTED
            break;
                                                   
        count -= copy;
                                               
        buf += copy;
                                                 
4000778c:	b6 06 c0 1d 	add  %i3, %i5, %i3
                            <== NOT EXECUTED
        blkofs = 0;
                                                  
        block++;
                                                     
40007790:	b2 06 60 01 	inc  %i1
                                      <== NOT EXECUTED
    while (count > 0)
                                                
40007794:	b8 a7 00 1d 	subcc  %i4, %i5, %i4
                          <== NOT EXECUTED
40007798:	02 80 00 0c 	be  400077c8 <rtems_blkdev_generic_read+0xe0>
 <== NOT EXECUTED
4000779c:	a0 10 20 00 	clr  %l0
                                      <== NOT EXECUTED
        rc = rtems_bdbuf_read(dd, block, &diskbuf);
                  
400077a0:	92 10 00 19 	mov  %i1, %o1
                                 <== NOT EXECUTED
400077a4:	94 07 bf fc 	add  %fp, -4, %o2
                             <== NOT EXECUTED
400077a8:	7f ff fc 60 	call  40006928 <rtems_bdbuf_read>
             <== NOT EXECUTED
400077ac:	90 10 00 12 	mov  %l2, %o0
                                 <== NOT EXECUTED
400077b0:	b0 10 00 08 	mov  %o0, %i0
                                 <== NOT EXECUTED
        if (rc != RTEMS_SUCCESSFUL)
                                  
400077b4:	80 a6 20 00 	cmp  %i0, 0
                                   <== NOT EXECUTED
400077b8:	02 bf ff e4 	be  40007748 <rtems_blkdev_generic_read+0x60>
 <== NOT EXECUTED
400077bc:	90 10 00 1b 	mov  %i3, %o0
                                 <== NOT EXECUTED
    }
                                                                

                                                                     
    return rc;
                                                       
}
                                                                    
400077c0:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
400077c4:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
{
                                                                    
400077c8:	b0 10 20 00 	clr  %i0
                                      <== NOT EXECUTED
400077cc:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
400077d0:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED

                                                                     
===============================================================================
400077d4 <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)
                                   
{
                                                                    
400077d4:	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;
                              
400077d8:	c2 06 80 00 	ld  [ %i2 ], %g1
                              <== NOT EXECUTED
400077dc:	e2 00 60 28 	ld  [ %g1 + 0x28 ], %l1
                       <== 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);

400077e0:	f8 1e a0 08 	ldd  [ %i2 + 8 ], %i4
                         <== NOT EXECUTED
    uint32_t block_size = dd->block_size;
                            
400077e4:	e0 04 60 24 	ld  [ %l1 + 0x24 ], %l0
                       <== NOT EXECUTED
    rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);

400077e8:	94 10 20 00 	clr  %o2
                                      <== NOT EXECUTED
400077ec:	96 10 00 10 	mov  %l0, %o3
                                 <== NOT EXECUTED
400077f0:	90 10 00 1c 	mov  %i4, %o0
                                 <== NOT EXECUTED
400077f4:	40 01 c8 d4 	call  40079b44 <__divdi3>
                     <== NOT EXECUTED
400077f8:	92 10 00 1d 	mov  %i5, %o1
                                 <== NOT EXECUTED
    uint32_t blkofs = (uint32_t) (args->offset % block_size);
        
400077fc:	90 10 00 1c 	mov  %i4, %o0
                                 <== NOT EXECUTED
    rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);

40007800:	b0 10 00 09 	mov  %o1, %i0
                                 <== NOT EXECUTED
    uint32_t blkofs = (uint32_t) (args->offset % block_size);
        
40007804:	94 10 20 00 	clr  %o2
                                      <== NOT EXECUTED
40007808:	96 10 00 10 	mov  %l0, %o3
                                 <== NOT EXECUTED
4000780c:	40 01 c9 59 	call  40079d70 <__moddi3>
                     <== NOT EXECUTED
40007810:	92 10 00 1d 	mov  %i5, %o1
                                 <== NOT EXECUTED

                                                                     
    args->bytes_moved = 0;
                                           
40007814:	c0 26 a0 1c 	clr  [ %i2 + 0x1c ]
                           <== NOT EXECUTED
    uint32_t blkofs = (uint32_t) (args->offset % block_size);
        
40007818:	b6 10 00 09 	mov  %o1, %i3
                                 <== NOT EXECUTED
    uint32_t count = args->count;
                                    
4000781c:	f8 06 a0 14 	ld  [ %i2 + 0x14 ], %i4
                       <== NOT EXECUTED

                                                                     
    while (count > 0)
                                                
40007820:	80 a7 20 00 	cmp  %i4, 0
                                   <== NOT EXECUTED
40007824:	12 80 00 21 	bne  400078a8 <rtems_blkdev_generic_write+0xd4>
<== NOT EXECUTED
40007828:	f2 06 a0 10 	ld  [ %i2 + 0x10 ], %i1
                       <== NOT EXECUTED
{
                                                                    
4000782c:	10 80 00 2c 	b  400078dc <rtems_blkdev_generic_write+0x108>
<== NOT EXECUTED
40007830:	90 10 20 00 	clr  %o0
                                      <== NOT EXECUTED
    {
                                                                
        rtems_bdbuf_buffer *diskbuf;
                                 
        uint32_t            copy;
                                    

                                                                     
        if ((blkofs == 0) && (count >= block_size))
                  
40007834:	0a 80 00 20 	bcs  400078b4 <rtems_blkdev_generic_write+0xe0>
<== NOT EXECUTED
40007838:	94 07 bf fc 	add  %fp, -4, %o2
                             <== NOT EXECUTED
            rc = rtems_bdbuf_get(dd, block, &diskbuf);
               
4000783c:	92 10 00 18 	mov  %i0, %o1
                                 <== NOT EXECUTED
40007840:	7f ff fb fa 	call  40006828 <rtems_bdbuf_get>
              <== NOT EXECUTED
40007844:	90 10 00 11 	mov  %l1, %o0
                                 <== NOT EXECUTED
        else
                                                         
            rc = rtems_bdbuf_read(dd, block, &diskbuf);
              
        if (rc != RTEMS_SUCCESSFUL)
                                  
40007848:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
4000784c:	12 80 00 21 	bne  400078d0 <rtems_blkdev_generic_write+0xfc>
<== NOT EXECUTED
40007850:	92 10 00 19 	mov  %i1, %o1
                                 <== NOT EXECUTED
            break;
                                                   

                                                                     
        copy = block_size - blkofs;
                                  
40007854:	ba 24 00 1b 	sub  %l0, %i3, %i5
                            <== NOT EXECUTED
40007858:	80 a7 40 1c 	cmp  %i5, %i4
                                 <== NOT EXECUTED
4000785c:	38 80 00 02 	bgu,a   40007864 <rtems_blkdev_generic_write+0x90>
<== NOT EXECUTED
40007860:	ba 10 00 1c 	mov  %i4, %i5
                                 <== NOT EXECUTED
        if (copy > count)
                                            
            copy = count;
                                            
        memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
         
40007864:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1
                         <== NOT EXECUTED
40007868:	d0 00 60 1c 	ld  [ %g1 + 0x1c ], %o0
                       <== NOT EXECUTED
4000786c:	94 10 00 1d 	mov  %i5, %o2
                                 <== NOT EXECUTED
40007870:	40 01 65 d8 	call  40060fd0 <memcpy>
                       <== NOT EXECUTED
40007874:	90 02 00 1b 	add  %o0, %i3, %o0
                            <== NOT EXECUTED
        args->bytes_moved += copy;
                                   
40007878:	c2 06 a0 1c 	ld  [ %i2 + 0x1c ], %g1
                       <== NOT EXECUTED
4000787c:	82 00 40 1d 	add  %g1, %i5, %g1
                            <== NOT EXECUTED
40007880:	c2 26 a0 1c 	st  %g1, [ %i2 + 0x1c ]
                       <== NOT EXECUTED
        rc = rtems_bdbuf_release_modified(diskbuf);
                  
        if (rc != RTEMS_SUCCESSFUL)
                                  
            break;
                                                   

                                                                     
        count -= copy;
                                               
        buf += copy;
                                                 
40007884:	b2 06 40 1d 	add  %i1, %i5, %i1
                            <== NOT EXECUTED
        rc = rtems_bdbuf_release_modified(diskbuf);
                  
40007888:	7f ff fc f7 	call  40006c64 <rtems_bdbuf_release_modified>
 <== NOT EXECUTED
4000788c:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0
                         <== NOT EXECUTED
        if (rc != RTEMS_SUCCESSFUL)
                                  
40007890:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
40007894:	12 80 00 0f 	bne  400078d0 <rtems_blkdev_generic_write+0xfc>
<== NOT EXECUTED
40007898:	b8 a7 00 1d 	subcc  %i4, %i5, %i4
                          <== NOT EXECUTED
        blkofs = 0;
                                                  
        block++;
                                                     
4000789c:	b0 06 20 01 	inc  %i0
                                      <== NOT EXECUTED
    while (count > 0)
                                                
400078a0:	02 80 00 0e 	be  400078d8 <rtems_blkdev_generic_write+0x104>
<== NOT EXECUTED
400078a4:	b6 10 20 00 	clr  %i3
                                      <== NOT EXECUTED
        if ((blkofs == 0) && (count >= block_size))
                  
400078a8:	80 a6 e0 00 	cmp  %i3, 0
                                   <== NOT EXECUTED
400078ac:	02 bf ff e2 	be  40007834 <rtems_blkdev_generic_write+0x60>
<== NOT EXECUTED
400078b0:	80 a7 00 10 	cmp  %i4, %l0
                                 <== NOT EXECUTED
            rc = rtems_bdbuf_read(dd, block, &diskbuf);
              
400078b4:	92 10 00 18 	mov  %i0, %o1
                                 <== NOT EXECUTED
400078b8:	94 07 bf fc 	add  %fp, -4, %o2
                             <== NOT EXECUTED
400078bc:	7f ff fc 1b 	call  40006928 <rtems_bdbuf_read>
             <== NOT EXECUTED
400078c0:	90 10 00 11 	mov  %l1, %o0
                                 <== NOT EXECUTED
        if (rc != RTEMS_SUCCESSFUL)
                                  
400078c4:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
400078c8:	02 bf ff e3 	be  40007854 <rtems_blkdev_generic_write+0x80>
<== NOT EXECUTED
400078cc:	92 10 00 19 	mov  %i1, %o1
                                 <== NOT EXECUTED
    }
                                                                

                                                                     
    return rc;
                                                       
}
                                                                    
400078d0:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
400078d4:	91 e8 00 08 	restore  %g0, %o0, %o0
                        <== NOT EXECUTED
{
                                                                    
400078d8:	90 10 20 00 	clr  %o0
                                      <== NOT EXECUTED
}
                                                                    
400078dc:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
400078e0:	91 e8 00 08 	restore  %g0, %o0, %o0
                        <== NOT EXECUTED

                                                                     
===============================================================================
4003d154 <rtems_blkdev_ioctl>:
                                       
#include <rtems/blkdev.h>
                                            
#include <rtems/bdbuf.h>
                                             

                                                                     
int
                                                                  
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
  
{
                                                                    
4003d154:	9d e3 bf a0 	save  %sp, -96, %sp
                           <== NOT EXECUTED
    rtems_status_code  sc;
                                           
    int                rc = 0;
                                       

                                                                     
    switch (req)
                                                     
4003d158:	03 10 01 10 	sethi  %hi(0x40044000), %g1
                   <== NOT EXECUTED
4003d15c:	84 10 62 03 	or  %g1, 0x203, %g2	! 40044203 <rtems_rate_monotonic_report_statistics_with_plugin+0x11f>
<== NOT EXECUTED
4003d160:	80 a6 40 02 	cmp  %i1, %g2
                                 <== NOT EXECUTED
4003d164:	22 80 00 4e 	be,a   4003d29c <rtems_blkdev_ioctl+0x148>
    <== NOT EXECUTED
4003d168:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1
                       <== NOT EXECUTED
4003d16c:	08 80 00 18 	bleu  4003d1cc <rtems_blkdev_ioctl+0x78>
      <== NOT EXECUTED
4003d170:	05 08 00 10 	sethi  %hi(0x20004000), %g2
                   <== NOT EXECUTED
4003d174:	84 10 62 09 	or  %g1, 0x209, %g2
                           <== NOT EXECUTED
4003d178:	80 a6 40 02 	cmp  %i1, %g2
                                 <== NOT EXECUTED
4003d17c:	22 80 00 4b 	be,a   4003d2a8 <rtems_blkdev_ioctl+0x154>
    <== NOT EXECUTED
4003d180:	f0 26 80 00 	st  %i0, [ %i2 ]
                              <== NOT EXECUTED
4003d184:	28 80 00 3b 	bleu,a   4003d270 <rtems_blkdev_ioctl+0x11c>
  <== NOT EXECUTED
4003d188:	82 10 62 05 	or  %g1, 0x205, %g1
                           <== NOT EXECUTED
4003d18c:	82 10 62 0b 	or  %g1, 0x20b, %g1
                           <== NOT EXECUTED
4003d190:	80 a6 40 01 	cmp  %i1, %g1
                                 <== NOT EXECUTED
4003d194:	02 80 00 23 	be  4003d220 <rtems_blkdev_ioctl+0xcc>
        <== NOT EXECUTED
4003d198:	03 20 01 10 	sethi  %hi(0x80044000), %g1
                   <== NOT EXECUTED
4003d19c:	82 10 62 04 	or  %g1, 0x204, %g1	! 80044204 <RAM_END+0x3fc44204>
<== NOT EXECUTED
4003d1a0:	80 a6 40 01 	cmp  %i1, %g1
                                 <== NOT EXECUTED
4003d1a4:	12 80 00 43 	bne  4003d2b0 <rtems_blkdev_ioctl+0x15c>
      <== NOT EXECUTED
4003d1a8:	94 10 20 01 	mov  1, %o2
                                   <== NOT EXECUTED
        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);

4003d1ac:	d2 06 80 00 	ld  [ %i2 ], %o1
                              <== NOT EXECUTED
4003d1b0:	7f ff 27 52 	call  40006ef8 <rtems_bdbuf_set_block_size>
   <== NOT EXECUTED
4003d1b4:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
            if (sc != RTEMS_SUCCESSFUL) {
                            
4003d1b8:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
4003d1bc:	12 80 00 27 	bne  4003d258 <rtems_blkdev_ioctl+0x104>
      <== NOT EXECUTED
4003d1c0:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
            }
                                                        
            break;
                                                   

                                                                     
        case RTEMS_BLKIO_GETSIZE:
                                    
            *(rtems_blkdev_bnum *) argp = dd->size;
                  
            break;
                                                   
4003d1c4:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4003d1c8:	91 e8 20 00 	restore  %g0, 0, %o0
                          <== NOT EXECUTED
    switch (req)
                                                     
4003d1cc:	86 10 a2 0a 	or  %g2, 0x20a, %g3
                           <== NOT EXECUTED
4003d1d0:	80 a6 40 03 	cmp  %i1, %g3
                                 <== NOT EXECUTED
4003d1d4:	02 80 00 2e 	be  4003d28c <rtems_blkdev_ioctl+0x138>
       <== NOT EXECUTED
4003d1d8:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
4003d1dc:	28 80 00 17 	bleu,a   4003d238 <rtems_blkdev_ioctl+0xe4>
   <== NOT EXECUTED
4003d1e0:	84 10 a2 06 	or  %g2, 0x206, %g2
                           <== NOT EXECUTED
4003d1e4:	84 10 a2 0c 	or  %g2, 0x20c, %g2
                           <== NOT EXECUTED
4003d1e8:	80 a6 40 02 	cmp  %i1, %g2
                                 <== NOT EXECUTED
4003d1ec:	02 80 00 09 	be  4003d210 <rtems_blkdev_ioctl+0xbc>
        <== NOT EXECUTED
4003d1f0:	82 10 62 02 	or  %g1, 0x202, %g1
                           <== NOT EXECUTED
4003d1f4:	80 a6 40 01 	cmp  %i1, %g1
                                 <== NOT EXECUTED
4003d1f8:	12 80 00 2e 	bne  4003d2b0 <rtems_blkdev_ioctl+0x15c>
      <== NOT EXECUTED
4003d1fc:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
            *(uint32_t *) argp = dd->media_block_size;
               
4003d200:	c2 06 20 20 	ld  [ %i0 + 0x20 ], %g1
                       <== NOT EXECUTED
4003d204:	c2 26 80 00 	st  %g1, [ %i2 ]
                              <== NOT EXECUTED
            break;
                                                   
4003d208:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4003d20c:	91 e8 20 00 	restore  %g0, 0, %o0
                          <== NOT EXECUTED
        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);
                      
4003d210:	7f ff 27 93 	call  4000705c <rtems_bdbuf_reset_device_stats>
<== NOT EXECUTED
4003d214:	b0 10 20 00 	clr  %i0
                                      <== NOT EXECUTED
            break;
                                                   
4003d218:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4003d21c:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
            rtems_bdbuf_get_device_stats(dd, (rtems_blkdev_stats *) argp);

4003d220:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
4003d224:	92 10 00 1a 	mov  %i2, %o1
                                 <== NOT EXECUTED
4003d228:	7f ff 27 82 	call  40007030 <rtems_bdbuf_get_device_stats>
 <== NOT EXECUTED
4003d22c:	b0 10 20 00 	clr  %i0
                                      <== NOT EXECUTED
            break;
                                                   
4003d230:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4003d234:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
    switch (req)
                                                     
4003d238:	80 a6 40 02 	cmp  %i1, %g2
                                 <== NOT EXECUTED
4003d23c:	12 80 00 1d 	bne  4003d2b0 <rtems_blkdev_ioctl+0x15c>
      <== NOT EXECUTED
4003d240:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
            sc = rtems_bdbuf_syncdev(dd);
                            
4003d244:	7f ff 27 0a 	call  40006e6c <rtems_bdbuf_syncdev>
          <== NOT EXECUTED
4003d248:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
            if (sc != RTEMS_SUCCESSFUL) {
                            
4003d24c:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
4003d250:	02 bf ff dd 	be  4003d1c4 <rtems_blkdev_ioctl+0x70>
        <== NOT EXECUTED
4003d254:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
                errno = EIO;
                                         
4003d258:	40 00 7d af 	call  4005c914 <__errno>
                      <== NOT EXECUTED
4003d25c:	b0 10 3f ff 	mov  -1, %i0	! ffffffff <RAM_END+0xbfbfffff>
  <== NOT EXECUTED
4003d260:	82 10 20 05 	mov  5, %g1
                                   <== NOT EXECUTED
4003d264:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
4003d268:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4003d26c:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
    switch (req)
                                                     
4003d270:	80 a6 40 01 	cmp  %i1, %g1
                                 <== NOT EXECUTED
4003d274:	12 80 00 0f 	bne  4003d2b0 <rtems_blkdev_ioctl+0x15c>
      <== NOT EXECUTED
4003d278:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
            *(rtems_blkdev_bnum *) argp = dd->size;
                  
4003d27c:	c2 06 20 1c 	ld  [ %i0 + 0x1c ], %g1
                       <== NOT EXECUTED
4003d280:	c2 26 80 00 	st  %g1, [ %i2 ]
                              <== NOT EXECUTED
            break;
                                                   
4003d284:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4003d288:	91 e8 20 00 	restore  %g0, 0, %o0
                          <== NOT EXECUTED
            rtems_bdbuf_purge_dev(dd);
                               
4003d28c:	7f ff 27 11 	call  40006ed0 <rtems_bdbuf_purge_dev>
        <== NOT EXECUTED
4003d290:	b0 10 20 00 	clr  %i0
                                      <== NOT EXECUTED
            break;
                                                   
4003d294:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4003d298:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
            *(uint32_t *) argp = dd->block_size;
                     
4003d29c:	c2 26 80 00 	st  %g1, [ %i2 ]
                              <== NOT EXECUTED
            break;
                                                   
4003d2a0:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4003d2a4:	91 e8 20 00 	restore  %g0, 0, %o0
                          <== NOT EXECUTED
            break;
                                                   
4003d2a8:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4003d2ac:	91 e8 20 00 	restore  %g0, 0, %o0
                          <== NOT EXECUTED

                                                                     
        default:
                                                     
            errno = EINVAL;
                                          
4003d2b0:	40 00 7d 99 	call  4005c914 <__errno>
                      <== NOT EXECUTED
4003d2b4:	b0 10 3f ff 	mov  -1, %i0
                                  <== NOT EXECUTED
4003d2b8:	82 10 20 16 	mov  0x16, %g1
                                <== NOT EXECUTED
4003d2bc:	c2 22 00 00 	st  %g1, [ %o0 ]
                              <== NOT EXECUTED
            rc = -1;
                                                 
            break;
                                                   
    }
                                                                

                                                                     
    return rc;
                                                       
}
                                                                    
4003d2c0:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4003d2c4:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED

                                                                     
===============================================================================
4003d2c8 <rtems_blkdev_print_stats>:
                                 
  uint32_t media_block_size,
                                         
  uint32_t media_block_count,
                                        
  uint32_t block_size,
                                               
  const rtems_printer* printer
                                       
)
                                                                    
{
                                                                    
4003d2c8:	9d e3 bf 80 	save  %sp, -128, %sp
                          <== NOT EXECUTED
  rtems_printf(
                                                      
4003d2cc:	da 06 20 1c 	ld  [ %i0 + 0x1c ], %o5
                       <== NOT EXECUTED
4003d2d0:	de 06 20 18 	ld  [ %i0 + 0x18 ], %o7
                       <== NOT EXECUTED
4003d2d4:	fa 06 20 14 	ld  [ %i0 + 0x14 ], %i5
                       <== NOT EXECUTED
4003d2d8:	c8 06 20 10 	ld  [ %i0 + 0x10 ], %g4
                       <== NOT EXECUTED
4003d2dc:	c6 06 20 0c 	ld  [ %i0 + 0xc ], %g3
                        <== NOT EXECUTED
4003d2e0:	c4 06 20 08 	ld  [ %i0 + 8 ], %g2
                          <== NOT EXECUTED
4003d2e4:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1
                          <== NOT EXECUTED
4003d2e8:	da 23 a0 74 	st  %o5, [ %sp + 0x74 ]
                       <== NOT EXECUTED
4003d2ec:	98 10 00 1b 	mov  %i3, %o4
                                 <== NOT EXECUTED
4003d2f0:	de 23 a0 70 	st  %o7, [ %sp + 0x70 ]
                       <== NOT EXECUTED
4003d2f4:	96 10 00 1a 	mov  %i2, %o3
                                 <== NOT EXECUTED
4003d2f8:	fa 23 a0 6c 	st  %i5, [ %sp + 0x6c ]
                       <== NOT EXECUTED
4003d2fc:	94 10 00 19 	mov  %i1, %o2
                                 <== NOT EXECUTED
4003d300:	c8 23 a0 68 	st  %g4, [ %sp + 0x68 ]
                       <== NOT EXECUTED
4003d304:	13 10 02 0b 	sethi  %hi(0x40082c00), %o1
                   <== NOT EXECUTED
4003d308:	c6 23 a0 64 	st  %g3, [ %sp + 0x64 ]
                       <== NOT EXECUTED
4003d30c:	92 12 61 10 	or  %o1, 0x110, %o1
                           <== NOT EXECUTED
4003d310:	c4 23 a0 60 	st  %g2, [ %sp + 0x60 ]
                       <== NOT EXECUTED
4003d314:	90 10 00 1c 	mov  %i4, %o0
                                 <== NOT EXECUTED
4003d318:	c2 23 a0 5c 	st  %g1, [ %sp + 0x5c ]
                       <== NOT EXECUTED
4003d31c:	7f ff 3c af 	call  4000c5d8 <rtems_printf>
                 <== NOT EXECUTED
4003d320:	da 06 00 00 	ld  [ %i0 ], %o5
                              <== NOT EXECUTED
     stats->read_errors,
                                             
     stats->write_transfers,
                                         
     stats->write_blocks,
                                            
     stats->write_errors
                                             
  );
                                                                 
}
                                                                    
4003d324:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4003d328:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED

                                                                     
===============================================================================
4003cf84 <rtems_blkstats>:
                                           
#include <unistd.h>
                                                  
#include <errno.h>
                                                   
#include <string.h>
                                                  

                                                                     
void rtems_blkstats(const rtems_printer* printer, const char *device, bool reset)

{
                                                                    
4003cf84:	9d e3 bf 10 	save  %sp, -240, %sp
                          <== NOT EXECUTED
  int fd = open(device, O_RDONLY);
                                   
4003cf88:	92 10 20 00 	clr  %o1
                                      <== NOT EXECUTED
4003cf8c:	7f ff 3c e4 	call  4000c31c <open>
                         <== NOT EXECUTED
4003cf90:	90 10 00 19 	mov  %i1, %o0
                                 <== NOT EXECUTED

                                                                     
  if (fd >= 0) {
                                                     
4003cf94:	ba 92 20 00 	orcc  %o0, 0, %i5
                             <== NOT EXECUTED
4003cf98:	06 80 00 45 	bl  4003d0ac <rtems_blkstats+0x128>
           <== NOT EXECUTED
4003cf9c:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
    struct stat st;
                                                  
    int rv;
                                                          

                                                                     
    rv = fstat(fd, &st);
                                             
4003cfa0:	7f ff 39 ce 	call  4000b6d8 <fstat>
                        <== NOT EXECUTED
4003cfa4:	92 07 bf a0 	add  %fp, -96, %o1
                            <== NOT EXECUTED
    if (rv == 0) {
                                                   
4003cfa8:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
4003cfac:	12 80 00 25 	bne  4003d040 <rtems_blkstats+0xbc>
           <== NOT EXECUTED
4003cfb0:	05 00 00 3c 	sethi  %hi(0xf000), %g2
                       <== NOT EXECUTED
      if (S_ISBLK(st.st_mode)) {
                                     
4003cfb4:	c2 07 bf ac 	ld  [ %fp + -84 ], %g1
                        <== NOT EXECUTED
4003cfb8:	82 08 40 02 	and  %g1, %g2, %g1
                            <== NOT EXECUTED
4003cfbc:	05 00 00 18 	sethi  %hi(0x6000), %g2
                       <== NOT EXECUTED
4003cfc0:	80 a0 40 02 	cmp  %g1, %g2
                                 <== NOT EXECUTED
4003cfc4:	12 80 00 45 	bne  4003d0d8 <rtems_blkstats+0x154>
          <== NOT EXECUTED
4003cfc8:	80 a6 a0 00 	cmp  %i2, 0
                                   <== NOT EXECUTED
        if (reset) {
                                                 
4003cfcc:	12 80 00 48 	bne  4003d0ec <rtems_blkstats+0x168>
          <== NOT EXECUTED
4003cfd0:	90 10 00 1d 	mov  %i5, %o0
                                 <== NOT EXECUTED
  return ioctl(fd, RTEMS_BLKIO_GETMEDIABLKSIZE, media_block_size);
   
4003cfd4:	39 10 01 10 	sethi  %hi(0x40044000), %i4
                   <== NOT EXECUTED
4003cfd8:	94 07 bf 74 	add  %fp, -140, %o2
                           <== NOT EXECUTED
4003cfdc:	92 17 22 02 	or  %i4, 0x202, %o1
                           <== NOT EXECUTED
          rv = rtems_disk_fd_reset_device_stats(fd);
                 
          if (rv != 0) {
                                             
            rtems_printf(printer, "error: reset stats: %s\n", strerror(errno));

          }
                                                          
        } else {
                                                     
          uint32_t media_block_size = 0;
                             
4003cfe0:	c0 27 bf 74 	clr  [ %fp + -140 ]
                           <== NOT EXECUTED
          uint32_t media_block_count = 0;
                            
4003cfe4:	c0 27 bf 78 	clr  [ %fp + -136 ]
                           <== NOT EXECUTED
4003cfe8:	7f ff 3a 23 	call  4000b874 <ioctl>
                        <== NOT EXECUTED
4003cfec:	c0 27 bf 7c 	clr  [ %fp + -132 ]
                           <== NOT EXECUTED
  return ioctl(fd, RTEMS_BLKIO_GETSIZE, block_count);
                
4003cff0:	94 07 bf 78 	add  %fp, -136, %o2
                           <== NOT EXECUTED
4003cff4:	92 17 22 05 	or  %i4, 0x205, %o1
                           <== NOT EXECUTED
4003cff8:	7f ff 3a 1f 	call  4000b874 <ioctl>
                        <== NOT EXECUTED
4003cffc:	90 10 00 1d 	mov  %i5, %o0
                                 <== NOT EXECUTED
  return ioctl(fd, RTEMS_BLKIO_GETBLKSIZE, block_size);
              
4003d000:	94 07 bf 7c 	add  %fp, -132, %o2
                           <== NOT EXECUTED
4003d004:	92 17 22 03 	or  %i4, 0x203, %o1
                           <== NOT EXECUTED
4003d008:	7f ff 3a 1b 	call  4000b874 <ioctl>
                        <== NOT EXECUTED
4003d00c:	90 10 00 1d 	mov  %i5, %o0
                                 <== NOT EXECUTED
static inline int rtems_disk_fd_get_device_stats(
                    
  int fd,
                                                            
  rtems_blkdev_stats *stats
                                          
)
                                                                    
{
                                                                    
  return ioctl(fd, RTEMS_BLKIO_GETDEVSTATS, stats);
                  
4003d010:	94 07 bf 80 	add  %fp, -128, %o2
                           <== NOT EXECUTED
4003d014:	92 17 22 0b 	or  %i4, 0x20b, %o1
                           <== NOT EXECUTED
4003d018:	7f ff 3a 17 	call  4000b874 <ioctl>
                        <== NOT EXECUTED
4003d01c:	90 10 00 1d 	mov  %i5, %o0
                                 <== NOT EXECUTED
          rtems_disk_fd_get_media_block_size(fd, &media_block_size);
 
          rtems_disk_fd_get_block_count(fd, &media_block_count);
     
          rtems_disk_fd_get_block_size(fd, &block_size);
             

                                                                     
          rv = rtems_disk_fd_get_device_stats(fd, &stats);
           
          if (rv == 0) {
                                             
4003d020:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
4003d024:	12 80 00 42 	bne  4003d12c <rtems_blkstats+0x1a8>
          <== NOT EXECUTED
4003d028:	d4 1f bf 78 	ldd  [ %fp + -136 ], %o2
                      <== NOT EXECUTED
            rtems_blkdev_print_stats(
                                
4003d02c:	d2 07 bf 74 	ld  [ %fp + -140 ], %o1
                       <== NOT EXECUTED
4003d030:	98 10 00 18 	mov  %i0, %o4
                                 <== NOT EXECUTED
4003d034:	40 00 00 a5 	call  4003d2c8 <rtems_blkdev_print_stats>
     <== NOT EXECUTED
4003d038:	90 07 bf 80 	add  %fp, -128, %o0
                           <== NOT EXECUTED
4003d03c:	30 80 00 0a 	b,a   4003d064 <rtems_blkstats+0xe0>
          <== NOT EXECUTED
        }
                                                            
      } else {
                                                       
        rtems_printf(printer, "error: not a block device\n");
        
      }
                                                              
    } else {
                                                         
      rtems_printf(printer, "error: get file stats: %s\n", strerror(errno));

4003d040:	40 00 7e 35 	call  4005c914 <__errno>
                      <== NOT EXECUTED
4003d044:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
4003d048:	40 00 9d 56 	call  400645a0 <strerror>
                     <== NOT EXECUTED
4003d04c:	d0 02 00 00 	ld  [ %o0 ], %o0
                              <== NOT EXECUTED
4003d050:	13 10 02 0b 	sethi  %hi(0x40082c00), %o1
                   <== NOT EXECUTED
4003d054:	94 10 00 08 	mov  %o0, %o2
                                 <== NOT EXECUTED
4003d058:	92 12 60 b8 	or  %o1, 0xb8, %o1
                            <== NOT EXECUTED
4003d05c:	7f ff 3d 5f 	call  4000c5d8 <rtems_printf>
                 <== NOT EXECUTED
4003d060:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
    }
                                                                

                                                                     
    rv = close(fd);
                                                  
4003d064:	7f ff 38 c2 	call  4000b36c <close>
                        <== NOT EXECUTED
4003d068:	90 10 00 1d 	mov  %i5, %o0
                                 <== NOT EXECUTED
    if (rv != 0) {
                                                   
4003d06c:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
4003d070:	12 80 00 04 	bne  4003d080 <rtems_blkstats+0xfc>
           <== NOT EXECUTED
4003d074:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
      rtems_printf(printer, "error: close device: %s\n", strerror(errno));

    }
                                                                
  } else {
                                                           
    rtems_printf(printer, "error: open device: %s\n", strerror(errno));

  }
                                                                  
}
                                                                    
4003d078:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4003d07c:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
      rtems_printf(printer, "error: close device: %s\n", strerror(errno));

4003d080:	40 00 7e 25 	call  4005c914 <__errno>
                      <== NOT EXECUTED
4003d084:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
4003d088:	40 00 9d 46 	call  400645a0 <strerror>
                     <== NOT EXECUTED
4003d08c:	d0 02 00 00 	ld  [ %o0 ], %o0
                              <== NOT EXECUTED
4003d090:	13 10 02 0b 	sethi  %hi(0x40082c00), %o1
                   <== NOT EXECUTED
4003d094:	94 10 00 08 	mov  %o0, %o2
                                 <== NOT EXECUTED
4003d098:	92 12 60 d8 	or  %o1, 0xd8, %o1
                            <== NOT EXECUTED
4003d09c:	7f ff 3d 4f 	call  4000c5d8 <rtems_printf>
                 <== NOT EXECUTED
4003d0a0:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
4003d0a4:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4003d0a8:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
    rtems_printf(printer, "error: open device: %s\n", strerror(errno));

4003d0ac:	40 00 7e 1a 	call  4005c914 <__errno>
                      <== NOT EXECUTED
4003d0b0:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
4003d0b4:	40 00 9d 3b 	call  400645a0 <strerror>
                     <== NOT EXECUTED
4003d0b8:	d0 02 00 00 	ld  [ %o0 ], %o0
                              <== NOT EXECUTED
4003d0bc:	13 10 02 0b 	sethi  %hi(0x40082c00), %o1
                   <== NOT EXECUTED
4003d0c0:	94 10 00 08 	mov  %o0, %o2
                                 <== NOT EXECUTED
4003d0c4:	92 12 60 f8 	or  %o1, 0xf8, %o1
                            <== NOT EXECUTED
4003d0c8:	7f ff 3d 44 	call  4000c5d8 <rtems_printf>
                 <== NOT EXECUTED
4003d0cc:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
}
                                                                    
4003d0d0:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4003d0d4:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
        rtems_printf(printer, "error: not a block device\n");
        
4003d0d8:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
4003d0dc:	13 10 02 0b 	sethi  %hi(0x40082c00), %o1
                   <== NOT EXECUTED
4003d0e0:	7f ff 3d 3e 	call  4000c5d8 <rtems_printf>
                 <== NOT EXECUTED
4003d0e4:	92 12 60 98 	or  %o1, 0x98, %o1	! 40082c98 <RTEMS_BDPART_MBR_MASTER_TYPE+0x40>
<== NOT EXECUTED
4003d0e8:	30 bf ff df 	b,a   4003d064 <rtems_blkstats+0xe0>
          <== NOT EXECUTED
}
                                                                    

                                                                     
static inline int rtems_disk_fd_reset_device_stats(int fd)
           
{
                                                                    
  return ioctl(fd, RTEMS_BLKIO_RESETDEVSTATS);
                       
4003d0ec:	13 08 00 10 	sethi  %hi(0x20004000), %o1
                   <== NOT EXECUTED
4003d0f0:	7f ff 39 e1 	call  4000b874 <ioctl>
                        <== NOT EXECUTED
4003d0f4:	92 12 62 0c 	or  %o1, 0x20c, %o1	! 2000420c <RAM_SIZE+0x1fc0420c>
<== NOT EXECUTED
          if (rv != 0) {
                                             
4003d0f8:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
4003d0fc:	02 bf ff da 	be  4003d064 <rtems_blkstats+0xe0>
            <== NOT EXECUTED
4003d100:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
            rtems_printf(printer, "error: reset stats: %s\n", strerror(errno));

4003d104:	40 00 7e 04 	call  4005c914 <__errno>
                      <== NOT EXECUTED
4003d108:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
4003d10c:	40 00 9d 25 	call  400645a0 <strerror>
                     <== NOT EXECUTED
4003d110:	d0 02 00 00 	ld  [ %o0 ], %o0
                              <== NOT EXECUTED
4003d114:	13 10 02 0b 	sethi  %hi(0x40082c00), %o1
                   <== NOT EXECUTED
4003d118:	94 10 00 08 	mov  %o0, %o2
                                 <== NOT EXECUTED
4003d11c:	92 12 60 68 	or  %o1, 0x68, %o1
                            <== NOT EXECUTED
4003d120:	7f ff 3d 2e 	call  4000c5d8 <rtems_printf>
                 <== NOT EXECUTED
4003d124:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
4003d128:	30 bf ff cf 	b,a   4003d064 <rtems_blkstats+0xe0>
          <== NOT EXECUTED
            rtems_printf(printer, "error: get stats: %s\n", strerror(errno));

4003d12c:	40 00 7d fa 	call  4005c914 <__errno>
                      <== NOT EXECUTED
4003d130:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
4003d134:	40 00 9d 1b 	call  400645a0 <strerror>
                     <== NOT EXECUTED
4003d138:	d0 02 00 00 	ld  [ %o0 ], %o0
                              <== NOT EXECUTED
4003d13c:	13 10 02 0b 	sethi  %hi(0x40082c00), %o1
                   <== NOT EXECUTED
4003d140:	94 10 00 08 	mov  %o0, %o2
                                 <== NOT EXECUTED
4003d144:	92 12 60 80 	or  %o1, 0x80, %o1
                            <== NOT EXECUTED
4003d148:	7f ff 3d 24 	call  4000c5d8 <rtems_printf>
                 <== NOT EXECUTED
4003d14c:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
4003d150:	30 bf ff c5 	b,a   4003d064 <rtems_blkstats+0xe0>
          <== NOT EXECUTED

                                                                     
===============================================================================
400086ec <rtems_disk_create_phys>:
                                   
{
                                                                    
400086ec:	9d e3 bf 98 	save  %sp, -104, %sp
                          <== NOT EXECUTED
  rtems_disk_device *dd = NULL;
                                      
400086f0:	c0 27 bf f8 	clr  [ %fp + -8 ]
                             <== NOT EXECUTED
{
                                                                    
400086f4:	a2 10 00 19 	mov  %i1, %l1
                                 <== NOT EXECUTED
  char *alloc_name = NULL;
                                           
400086f8:	c0 27 bf fc 	clr  [ %fp + -4 ]
                             <== NOT EXECUTED
{
                                                                    
400086fc:	a0 10 00 18 	mov  %i0, %l0
                                 <== NOT EXECUTED
  if (handler == NULL) {
                                             
40008700:	80 a7 20 00 	cmp  %i4, 0
                                   <== NOT EXECUTED
40008704:	02 80 00 20 	be  40008784 <rtems_disk_create_phys+0x98>
    <== NOT EXECUTED
40008708:	b2 10 20 09 	mov  9, %i1
                                   <== NOT EXECUTED
  _Mutex_Acquire( mutex );
                                           
4000870c:	31 10 02 2e 	sethi  %hi(0x4008b800), %i0
                   <== NOT EXECUTED
40008710:	40 00 4d c2 	call  4001be18 <_Mutex_Acquire>
               <== NOT EXECUTED
40008714:	90 16 21 f4 	or  %i0, 0x1f4, %o0	! 4008b9f4 <diskdevs_mutex>
<== NOT EXECUTED
  diskdevs_protected = true;
                                         
40008718:	82 10 20 01 	mov  1, %g1
                                   <== NOT EXECUTED
  sc = create_disk(dev, name, &dd, &alloc_name);
                     
4000871c:	d4 07 a0 5c 	ld  [ %fp + 0x5c ], %o2
                       <== NOT EXECUTED
  diskdevs_protected = true;
                                         
40008720:	25 10 02 36 	sethi  %hi(0x4008d800), %l2
                   <== NOT EXECUTED
  sc = create_disk(dev, name, &dd, &alloc_name);
                     
40008724:	98 07 bf fc 	add  %fp, -4, %o4
                             <== NOT EXECUTED
  diskdevs_protected = true;
                                         
40008728:	c2 2c a2 85 	stb  %g1, [ %l2 + 0x285 ]
                     <== NOT EXECUTED
  sc = create_disk(dev, name, &dd, &alloc_name);
                     
4000872c:	96 07 bf f8 	add  %fp, -8, %o3
                             <== NOT EXECUTED
40008730:	90 10 00 10 	mov  %l0, %o0
                                 <== NOT EXECUTED
40008734:	7f ff ff 03 	call  40008340 <create_disk>
                  <== NOT EXECUTED
40008738:	92 10 00 11 	mov  %l1, %o1
                                 <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL) {
                                      
4000873c:	b2 92 20 00 	orcc  %o0, 0, %i1
                             <== NOT EXECUTED
40008740:	12 80 00 0e 	bne  40008778 <rtems_disk_create_phys+0x8c>
   <== NOT EXECUTED
40008744:	d0 07 bf f8 	ld  [ %fp + -8 ], %o0
                         <== NOT EXECUTED
  sc = rtems_disk_init_phys(
                                         
40008748:	98 10 00 1d 	mov  %i5, %o4
                                 <== NOT EXECUTED
4000874c:	96 10 00 1c 	mov  %i4, %o3
                                 <== NOT EXECUTED
40008750:	94 10 00 1b 	mov  %i3, %o2
                                 <== NOT EXECUTED
40008754:	7f ff fe 97 	call  400081b0 <rtems_disk_init_phys>
         <== NOT EXECUTED
40008758:	92 10 00 1a 	mov  %i2, %o1
                                 <== NOT EXECUTED
  dd->dev = dev;
                                                     
4000875c:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1
                         <== NOT EXECUTED
  dd->name = alloc_name;
                                             
40008760:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2
                         <== NOT EXECUTED
40008764:	c4 20 60 10 	st  %g2, [ %g1 + 0x10 ]
                       <== NOT EXECUTED
  sc = rtems_disk_init_phys(
                                         
40008768:	b2 10 00 08 	mov  %o0, %i1
                                 <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL) {
                                      
4000876c:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
40008770:	12 80 00 07 	bne  4000878c <rtems_disk_create_phys+0xa0>
   <== NOT EXECUTED
40008774:	e0 38 40 00 	std  %l0, [ %g1 ]
                             <== NOT EXECUTED
  diskdevs_protected = false;
                                        
40008778:	c0 2c a2 85 	clrb  [ %l2 + 0x285 ]
                         <== NOT EXECUTED
  _Mutex_Release( mutex );
                                           
4000877c:	40 00 4d c3 	call  4001be88 <_Mutex_Release>
               <== NOT EXECUTED
40008780:	90 16 21 f4 	or  %i0, 0x1f4, %o0
                           <== NOT EXECUTED
}
                                                                    
40008784:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40008788:	91 e8 00 19 	restore  %g0, %i1, %o0
                        <== NOT EXECUTED
    dd->ioctl = null_handler;
                                        
4000878c:	05 10 00 20 	sethi  %hi(0x40008000), %g2
                   <== NOT EXECUTED
40008790:	84 10 a3 38 	or  %g2, 0x338, %g2	! 40008338 <null_handler>
 <== NOT EXECUTED
40008794:	c4 20 60 38 	st  %g2, [ %g1 + 0x38 ]
                       <== NOT EXECUTED
    disk_delete_locked(dev);
                                         
40008798:	92 10 00 11 	mov  %l1, %o1
                                 <== NOT EXECUTED
4000879c:	7f ff ff 67 	call  40008538 <disk_delete_locked>
           <== NOT EXECUTED
400087a0:	90 10 00 10 	mov  %l0, %o0
                                 <== NOT EXECUTED
400087a4:	90 16 21 f4 	or  %i0, 0x1f4, %o0
                           <== NOT EXECUTED
  diskdevs_protected = false;
                                        
400087a8:	c0 2c a2 85 	clrb  [ %l2 + 0x285 ]
                         <== NOT EXECUTED
400087ac:	40 00 4d b7 	call  4001be88 <_Mutex_Release>
               <== NOT EXECUTED
400087b0:	b0 10 00 19 	mov  %i1, %i0
                                 <== NOT EXECUTED
}
                                                                    
400087b4:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
400087b8:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED

                                                                     
===============================================================================
400087bc <rtems_disk_delete>:
                                        

                                                                     
rtems_status_code
                                                    
rtems_disk_delete(dev_t dev)
                                         
{
                                                                    
400087bc:	9d e3 bf a0 	save  %sp, -96, %sp
                           <== NOT EXECUTED
  _Mutex_Acquire( mutex );
                                           
400087c0:	3b 10 02 2e 	sethi  %hi(0x4008b800), %i5
                   <== NOT EXECUTED
400087c4:	40 00 4d 95 	call  4001be18 <_Mutex_Acquire>
               <== NOT EXECUTED
400087c8:	90 17 61 f4 	or  %i5, 0x1f4, %o0	! 4008b9f4 <diskdevs_mutex>
<== NOT EXECUTED
  diskdevs_protected = true;
                                         
400087cc:	82 10 20 01 	mov  1, %g1
                                   <== NOT EXECUTED
400087d0:	39 10 02 36 	sethi  %hi(0x4008d800), %i4
                   <== NOT EXECUTED
  rtems_status_code sc;
                                              

                                                                     
  disk_lock();
                                                       
  sc = disk_delete_locked(dev);
                                      
400087d4:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
400087d8:	92 10 00 19 	mov  %i1, %o1
                                 <== NOT EXECUTED
  diskdevs_protected = true;
                                         
400087dc:	c2 2f 22 85 	stb  %g1, [ %i4 + 0x285 ]
                     <== NOT EXECUTED
  sc = disk_delete_locked(dev);
                                      
400087e0:	7f ff ff 56 	call  40008538 <disk_delete_locked>
           <== NOT EXECUTED
400087e4:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  diskdevs_protected = false;
                                        
400087e8:	c0 2f 22 85 	clrb  [ %i4 + 0x285 ]
                         <== NOT EXECUTED
  sc = disk_delete_locked(dev);
                                      
400087ec:	b0 10 00 08 	mov  %o0, %i0
                                 <== NOT EXECUTED
  _Mutex_Release( mutex );
                                           
400087f0:	40 00 4d a6 	call  4001be88 <_Mutex_Release>
               <== NOT EXECUTED
400087f4:	90 17 61 f4 	or  %i5, 0x1f4, %o0
                           <== NOT EXECUTED
  disk_unlock();
                                                     

                                                                     
  return sc;
                                                         
}
                                                                    
400087f8:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
400087fc:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED

                                                                     
===============================================================================
40008218 <rtems_disk_init_log>:
                                      
  rtems_disk_device *dd,
                                             
  rtems_disk_device *phys_dd,
                                        
  rtems_blkdev_bnum block_begin,
                                     
  rtems_blkdev_bnum block_count
                                      
)
                                                                    
{
                                                                    
40008218:	9d e3 bf a0 	save  %sp, -96, %sp
                           <== NOT EXECUTED
  rtems_status_code sc;
                                              

                                                                     
  dd = memset(dd, 0, sizeof(*dd));
                                   
4000821c:	94 10 20 78 	mov  0x78, %o2
                                <== NOT EXECUTED
40008220:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
40008224:	40 01 63 f5 	call  400611f8 <memset>
                       <== NOT EXECUTED
40008228:	92 10 20 00 	clr  %o1
                                      <== NOT EXECUTED
  dd->phys_dev = phys_dd;
                                            
  dd->start = block_begin;
                                           
  dd->size = block_count;
                                            
  dd->media_block_size = phys_dd->media_block_size;
                  
  dd->ioctl = phys_dd->ioctl;
                                        
  dd->driver_data = phys_dd->driver_data;
                            
4000822c:	c2 06 60 3c 	ld  [ %i1 + 0x3c ], %g1
                       <== NOT EXECUTED
  dd->media_block_size = phys_dd->media_block_size;
                  
40008230:	c6 06 60 20 	ld  [ %i1 + 0x20 ], %g3
                       <== NOT EXECUTED
  dd->ioctl = phys_dd->ioctl;
                                        
40008234:	c4 06 60 38 	ld  [ %i1 + 0x38 ], %g2
                       <== NOT EXECUTED
  dd->phys_dev = phys_dd;
                                            
40008238:	f2 22 20 08 	st  %i1, [ %o0 + 8 ]
                          <== NOT EXECUTED
  dd->driver_data = phys_dd->driver_data;
                            
4000823c:	c2 22 20 3c 	st  %g1, [ %o0 + 0x3c ]
                       <== NOT EXECUTED
  dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
         
40008240:	82 10 3f ff 	mov  -1, %g1
                                  <== NOT EXECUTED
  dd->start = block_begin;
                                           
40008244:	f4 22 20 18 	st  %i2, [ %o0 + 0x18 ]
                       <== NOT EXECUTED
  dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
         
40008248:	c2 22 20 6c 	st  %g1, [ %o0 + 0x6c ]
                       <== NOT EXECUTED
  dd->size = block_count;
                                            
4000824c:	f6 22 20 1c 	st  %i3, [ %o0 + 0x1c ]
                       <== NOT EXECUTED
  dd->media_block_size = phys_dd->media_block_size;
                  
40008250:	c6 22 20 20 	st  %g3, [ %o0 + 0x20 ]
                       <== NOT EXECUTED
  dd->ioctl = phys_dd->ioctl;
                                        
40008254:	c4 22 20 38 	st  %g2, [ %o0 + 0x38 ]
                       <== NOT EXECUTED

                                                                     
  if (phys_dd->phys_dev == phys_dd) {
                                
40008258:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1
                          <== NOT EXECUTED
4000825c:	80 a0 40 19 	cmp  %g1, %i1
                                 <== NOT EXECUTED
40008260:	02 80 00 04 	be  40008270 <rtems_disk_init_log+0x58>
       <== NOT EXECUTED
40008264:	b0 10 20 04 	mov  4, %i0
                                   <== NOT EXECUTED
  } else {
                                                           
    sc = RTEMS_INVALID_ID;
                                           
  }
                                                                  

                                                                     
  return sc;
                                                         
}
                                                                    
40008268:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
4000826c:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
    rtems_blkdev_bnum phys_block_count = phys_dd->size;
              
40008270:	c4 00 60 1c 	ld  [ %g1 + 0x1c ], %g2
                       <== NOT EXECUTED
    if (
                                                             
40008274:	80 a6 80 02 	cmp  %i2, %g2
                                 <== NOT EXECUTED
40008278:	1a 80 00 0a 	bcc  400082a0 <rtems_disk_init_log+0x88>
      <== NOT EXECUTED
4000827c:	80 a6 e0 00 	cmp  %i3, 0
                                   <== NOT EXECUTED
40008280:	02 80 00 08 	be  400082a0 <rtems_disk_init_log+0x88>
       <== NOT EXECUTED
40008284:	b4 20 80 1a 	sub  %g2, %i2, %i2
                            <== NOT EXECUTED
        && block_count <= phys_block_count - block_begin
             
40008288:	80 a6 80 1b 	cmp  %i2, %i3
                                 <== NOT EXECUTED
4000828c:	0a 80 00 05 	bcs  400082a0 <rtems_disk_init_log+0x88>
      <== NOT EXECUTED
40008290:	b4 10 20 00 	clr  %i2
                                      <== NOT EXECUTED
      sc = rtems_bdbuf_set_block_size(dd, phys_dd->media_block_size, false);

40008294:	f2 00 60 20 	ld  [ %g1 + 0x20 ], %i1
                       <== NOT EXECUTED
40008298:	7f ff fb 18 	call  40006ef8 <rtems_bdbuf_set_block_size>
   <== NOT EXECUTED
4000829c:	91 e8 00 08 	restore  %g0, %o0, %o0
                        <== NOT EXECUTED
}
                                                                    
400082a0:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
400082a4:	91 e8 20 0a 	restore  %g0, 0xa, %o0
                        <== NOT EXECUTED

                                                                     
===============================================================================
400081b0 <rtems_disk_init_phys>:
                                     
  uint32_t block_size,
                                               
  rtems_blkdev_bnum block_count,
                                     
  rtems_block_device_ioctl handler,
                                  
  void *driver_data
                                                  
)
                                                                    
{
                                                                    
400081b0:	9d e3 bf a0 	save  %sp, -96, %sp
                           <== NOT EXECUTED
  rtems_status_code sc;
                                              

                                                                     
  dd = memset(dd, 0, sizeof(*dd));
                                   
400081b4:	94 10 20 78 	mov  0x78, %o2
                                <== NOT EXECUTED
400081b8:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
400081bc:	40 01 64 0f 	call  400611f8 <memset>
                       <== NOT EXECUTED
400081c0:	92 10 20 00 	clr  %o1
                                      <== NOT EXECUTED
400081c4:	b0 10 00 08 	mov  %o0, %i0
                                 <== NOT EXECUTED

                                                                     
  dd->phys_dev = dd;
                                                 
400081c8:	d0 26 20 08 	st  %o0, [ %i0 + 8 ]
                          <== NOT EXECUTED
  dd->size = block_count;
                                            
  dd->media_block_size = block_size;
                                 
  dd->ioctl = handler;
                                               
  dd->driver_data = driver_data;
                                     
  dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
         
400081cc:	82 10 3f ff 	mov  -1, %g1
                                  <== NOT EXECUTED
  dd->size = block_count;
                                            
400081d0:	f4 22 20 1c 	st  %i2, [ %o0 + 0x1c ]
                       <== NOT EXECUTED

                                                                     
  if (block_count > 0) {
                                             
400081d4:	80 a6 a0 00 	cmp  %i2, 0
                                   <== NOT EXECUTED
  dd->media_block_size = block_size;
                                 
400081d8:	f2 22 20 20 	st  %i1, [ %o0 + 0x20 ]
                       <== NOT EXECUTED
  dd->ioctl = handler;
                                               
400081dc:	f6 22 20 38 	st  %i3, [ %o0 + 0x38 ]
                       <== NOT EXECUTED
  dd->driver_data = driver_data;
                                     
400081e0:	f8 22 20 3c 	st  %i4, [ %o0 + 0x3c ]
                       <== NOT EXECUTED
  if (block_count > 0) {
                                             
400081e4:	02 80 00 0b 	be  40008210 <rtems_disk_init_phys+0x60>
      <== NOT EXECUTED
400081e8:	c2 22 20 6c 	st  %g1, [ %o0 + 0x6c ]
                       <== NOT EXECUTED
    if ((*handler)(dd, RTEMS_BLKIO_CAPABILITIES, &dd->capabilities) != 0) {

400081ec:	94 02 20 0c 	add  %o0, 0xc, %o2
                            <== NOT EXECUTED
400081f0:	13 08 00 10 	sethi  %hi(0x20004000), %o1
                   <== NOT EXECUTED
400081f4:	9f c6 c0 00 	call  %i3
                                     <== NOT EXECUTED
400081f8:	92 12 62 08 	or  %o1, 0x208, %o1	! 20004208 <RAM_SIZE+0x1fc04208>
<== NOT EXECUTED
400081fc:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
40008200:	32 80 00 02 	bne,a   40008208 <rtems_disk_init_phys+0x58>
  <== NOT EXECUTED
40008204:	c0 26 20 0c 	clr  [ %i0 + 0xc ]
                            <== NOT EXECUTED
      dd->capabilities = 0;
                                          
    }
                                                                

                                                                     
    sc = rtems_bdbuf_set_block_size(dd, block_size, false);
          
40008208:	7f ff fb 3c 	call  40006ef8 <rtems_bdbuf_set_block_size>
   <== NOT EXECUTED
4000820c:	95 e8 20 00 	restore  %g0, 0, %o2
                          <== NOT EXECUTED
  } else {
                                                           
    sc = RTEMS_INVALID_NUMBER;
                                       
  }
                                                                  

                                                                     
  return sc;
                                                         
}
                                                                    
40008210:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40008214:	91 e8 20 0a 	restore  %g0, 0xa, %o0
                        <== NOT EXECUTED

                                                                     
===============================================================================
400088d4 <rtems_disk_io_initialize>:
                                 
  }
                                                                  
}
                                                                    

                                                                     
rtems_status_code
                                                    
rtems_disk_io_initialize(void)
                                       
{
                                                                    
400088d4:	9d e3 bf a0 	save  %sp, -96, %sp
                           <== NOT EXECUTED
  rtems_status_code sc = RTEMS_SUCCESSFUL;
                           
  rtems_device_major_number size = DISKTAB_INITIAL_SIZE;
             

                                                                     
  if (disktab_size > 0) {
                                            
400088d8:	3b 10 02 36 	sethi  %hi(0x4008d800), %i5
                   <== NOT EXECUTED
400088dc:	c2 07 62 88 	ld  [ %i5 + 0x288 ], %g1	! 4008da88 <disktab_size>
<== NOT EXECUTED
400088e0:	80 a0 60 00 	cmp  %g1, 0
                                   <== NOT EXECUTED
400088e4:	12 80 00 10 	bne  40008924 <rtems_disk_io_initialize+0x50>
 <== NOT EXECUTED
400088e8:	b0 10 20 00 	clr  %i0
                                      <== NOT EXECUTED
    return RTEMS_SUCCESSFUL;
                                         
  }
                                                                  

                                                                     
  disktab = calloc(size, sizeof(rtems_disk_device_table));
           
400088ec:	92 10 20 08 	mov  8, %o1
                                   <== NOT EXECUTED
400088f0:	90 10 20 08 	mov  8, %o0
                                   <== NOT EXECUTED
400088f4:	40 00 06 c3 	call  4000a400 <calloc>
                       <== NOT EXECUTED
400088f8:	39 10 02 36 	sethi  %hi(0x4008d800), %i4
                   <== NOT EXECUTED
400088fc:	d0 27 22 8c 	st  %o0, [ %i4 + 0x28c ]	! 4008da8c <disktab>
 <== NOT EXECUTED
  if (disktab == NULL) {
                                             
40008900:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
40008904:	02 80 00 08 	be  40008924 <rtems_disk_io_initialize+0x50>
  <== NOT EXECUTED
40008908:	b0 10 20 1a 	mov  0x1a, %i0
                                <== NOT EXECUTED
    return RTEMS_NO_MEMORY;
                                          
  }
                                                                  

                                                                     
  sc = rtems_bdbuf_init();
                                           
4000890c:	7f ff f7 bd 	call  40006800 <rtems_bdbuf_init>
             <== NOT EXECUTED
40008910:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL) {
                                      
40008914:	b0 92 20 00 	orcc  %o0, 0, %i0
                             <== NOT EXECUTED
40008918:	12 80 00 05 	bne  4000892c <rtems_disk_io_initialize+0x58>
 <== NOT EXECUTED
4000891c:	82 10 20 08 	mov  8, %g1
                                   <== NOT EXECUTED
    free(disktab);
                                                   

                                                                     
    return RTEMS_UNSATISFIED;
                                        
  }
                                                                  

                                                                     
  disktab_size = size;
                                               
40008920:	c2 27 62 88 	st  %g1, [ %i5 + 0x288 ]
                      <== NOT EXECUTED

                                                                     
  return RTEMS_SUCCESSFUL;
                                           
}
                                                                    
40008924:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40008928:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
    free(disktab);
                                                   
4000892c:	40 00 0b 55 	call  4000b680 <free>
                         <== NOT EXECUTED
40008930:	d0 07 22 8c 	ld  [ %i4 + 0x28c ], %o0
                      <== NOT EXECUTED
    return RTEMS_UNSATISFIED;
                                        
40008934:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40008938:	91 e8 20 0d 	restore  %g0, 0xd, %o0
                        <== NOT EXECUTED

                                                                     
===============================================================================
40008800 <rtems_disk_obtain>:
                                        

                                                                     
rtems_disk_device *
                                                  
rtems_disk_obtain(dev_t dev)
                                         
{
                                                                    
40008800:	9d e3 bf a0 	save  %sp, -96, %sp
                           <== NOT EXECUTED
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

40008804:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED
  return psr;
                                                        
40008808:	b8 10 00 01 	mov  %g1, %i4
                                 <== NOT EXECUTED
  rtems_disk_device *dd = NULL;
                                      
  rtems_interrupt_lock_context lock_context;
                         

                                                                     
  rtems_interrupt_lock_acquire(&diskdevs_lock, &lock_context);
       
  if (!diskdevs_protected) {
                                         
4000880c:	3b 10 02 36 	sethi  %hi(0x4008d800), %i5
                   <== NOT EXECUTED
40008810:	c4 0f 62 85 	ldub  [ %i5 + 0x285 ], %g2	! 4008da85 <diskdevs_protected>
<== NOT EXECUTED
40008814:	80 a0 a0 00 	cmp  %g2, 0
                                   <== NOT EXECUTED
40008818:	02 80 00 14 	be  40008868 <rtems_disk_obtain+0x68>
         <== NOT EXECUTED
4000881c:	94 10 20 00 	clr  %o2
                                      <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

40008820:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
40008824:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  _Mutex_Acquire( mutex );
                                           
40008828:	39 10 02 2e 	sethi  %hi(0x4008b800), %i4
                   <== NOT EXECUTED
4000882c:	40 00 4d 7b 	call  4001be18 <_Mutex_Acquire>
               <== NOT EXECUTED
40008830:	90 17 21 f4 	or  %i4, 0x1f4, %o0	! 4008b9f4 <diskdevs_mutex>
<== NOT EXECUTED
  diskdevs_protected = true;
                                         
40008834:	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);
                                 
40008838:	94 10 20 00 	clr  %o2
                                      <== NOT EXECUTED
4000883c:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
40008840:	92 10 00 19 	mov  %i1, %o1
                                 <== NOT EXECUTED
  diskdevs_protected = true;
                                         
40008844:	c2 2f 62 85 	stb  %g1, [ %i5 + 0x285 ]
                     <== NOT EXECUTED
    dd = get_disk_entry(dev, false);
                                 
40008848:	7f ff fe 98 	call  400082a8 <get_disk_entry>
               <== NOT EXECUTED
4000884c:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  diskdevs_protected = false;
                                        
40008850:	c0 2f 62 85 	clrb  [ %i5 + 0x285 ]
                         <== NOT EXECUTED
    dd = get_disk_entry(dev, false);
                                 
40008854:	b0 10 00 08 	mov  %o0, %i0
                                 <== NOT EXECUTED
  _Mutex_Release( mutex );
                                           
40008858:	40 00 4d 8c 	call  4001be88 <_Mutex_Release>
               <== NOT EXECUTED
4000885c:	90 17 21 f4 	or  %i4, 0x1f4, %o0
                           <== NOT EXECUTED
    disk_unlock();
                                                   
  }
                                                                  

                                                                     
  return dd;
                                                         
}
                                                                    
40008860:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40008864:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED
    dd = get_disk_entry(dev, false);
                                 
40008868:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
4000886c:	7f ff fe 8f 	call  400082a8 <get_disk_entry>
               <== NOT EXECUTED
40008870:	92 10 00 19 	mov  %i1, %o1
                                 <== NOT EXECUTED
40008874:	b0 10 00 08 	mov  %o0, %i0
                                 <== NOT EXECUTED
  register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */

40008878:	82 10 00 1c 	mov  %i4, %g1
                                 <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

4000887c:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
40008880:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
40008884:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
40008888:	81 e8 00 00 	restore 
                                      <== NOT EXECUTED

                                                                     
===============================================================================
4000888c <rtems_disk_release>:
                                       

                                                                     
rtems_status_code
                                                    
rtems_disk_release(rtems_disk_device *dd)
                            
{
                                                                    
4000888c:	9d e3 bf a0 	save  %sp, -96, %sp
                           <== NOT EXECUTED
  rtems_interrupt_lock_context lock_context;
                         
  dev_t dev = dd->dev;
                                               
40008890:	d0 1e 00 00 	ldd  [ %i0 ], %o0
                             <== NOT EXECUTED
  __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));

40008894:	91 d0 20 09 	ta  9
                                         <== NOT EXECUTED
  unsigned uses = 0;
                                                 
  bool deleted = false;
                                              

                                                                     
  rtems_interrupt_lock_acquire(&diskdevs_lock, &lock_context);
       
  uses = --dd->uses;
                                                 
40008898:	c4 06 20 14 	ld  [ %i0 + 0x14 ], %g2
                       <== NOT EXECUTED
4000889c:	84 00 bf ff 	add  %g2, -1, %g2
                             <== NOT EXECUTED
  deleted = dd->deleted;
                                             
400088a0:	c6 0e 20 40 	ldub  [ %i0 + 0x40 ], %g3
                     <== NOT EXECUTED
  uses = --dd->uses;
                                                 
400088a4:	c4 26 20 14 	st  %g2, [ %i0 + 0x14 ]
                       <== NOT EXECUTED
  __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));

400088a8:	91 d0 20 0a 	ta  0xa
                                       <== NOT EXECUTED
400088ac:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  rtems_interrupt_lock_release(&diskdevs_lock, &lock_context);
       

                                                                     
  if (uses == 0 && deleted) {
                                        
400088b0:	80 a0 a0 00 	cmp  %g2, 0
                                   <== NOT EXECUTED
400088b4:	12 80 00 06 	bne  400088cc <rtems_disk_release+0x40>
       <== NOT EXECUTED
400088b8:	80 88 e0 ff 	btst  0xff, %g3
                               <== NOT EXECUTED
400088bc:	02 80 00 04 	be  400088cc <rtems_disk_release+0x40>
        <== NOT EXECUTED
400088c0:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
    rtems_disk_delete(dev);
                                          
400088c4:	7f ff ff be 	call  400087bc <rtems_disk_delete>
            <== NOT EXECUTED
400088c8:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  }
                                                                  

                                                                     
  return RTEMS_SUCCESSFUL;
                                           
}
                                                                    
400088cc:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
400088d0:	91 e8 20 00 	restore  %g0, 0, %o0
                          <== NOT EXECUTED

                                                                     
===============================================================================
400390c0 <rtems_nvdisk_initialize>:
                                  
 */
                                                                  
rtems_device_driver
                                                  
rtems_nvdisk_initialize (rtems_device_major_number major,
            
                        rtems_device_minor_number minor,
             
                        void*                     arg RTEMS_UNUSED)
  
{
                                                                    
400390c0:	9d e3 bf 88 	save  %sp, -120, %sp
                          <== NOT EXECUTED
  const rtems_nvdisk_config* c = rtems_nvdisk_configuration;
         
  rtems_nvdisk*              nvd;
                                    
  rtems_status_code          sc;
                                     

                                                                     
  sc = rtems_disk_io_initialize ();
                                  
400390c4:	7f ff 3e 04 	call  400088d4 <rtems_disk_io_initialize>
     <== NOT EXECUTED
400390c8:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL)
                                        
400390cc:	ae 92 20 00 	orcc  %o0, 0, %l7
                             <== NOT EXECUTED
400390d0:	02 80 00 04 	be  400390e0 <rtems_nvdisk_initialize+0x20>
   <== NOT EXECUTED
400390d4:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
  }
                                                                  

                                                                     
  rtems_nvdisk_count = rtems_nvdisk_configuration_size;
              

                                                                     
  return RTEMS_SUCCESSFUL;
                                           
}
                                                                    
400390d8:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
400390dc:	91 e8 00 17 	restore  %g0, %l7, %o0
                        <== NOT EXECUTED
  rtems_nvdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);
      
400390e0:	7f ff 4b 2b 	call  4000bd8c <malloc>
                       <== NOT EXECUTED
400390e4:	90 10 22 00 	mov  0x200, %o0
                               <== NOT EXECUTED
400390e8:	03 10 02 40 	sethi  %hi(0x40090000), %g1
                   <== NOT EXECUTED
400390ec:	d0 20 62 38 	st  %o0, [ %g1 + 0x238 ]	! 40090238 <rtems_nvdisk_crc16_factor>
<== NOT EXECUTED
      v = v & 1 ? (v >> 1) ^ pattern : v >> 1;
                       
400390f0:	09 3f ff e1 	sethi  %hi(0xffff8400), %g4
                   <== NOT EXECUTED
  for (b = 0; b < 256; b++)
                                          
400390f4:	86 10 20 00 	clr  %g3
                                      <== NOT EXECUTED
  if (!rtems_nvdisk_crc16_factor)
                                    
400390f8:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
400390fc:	02 80 00 7c 	be  400392ec <rtems_nvdisk_initialize+0x22c>
  <== NOT EXECUTED
40039100:	88 11 20 08 	or  %g4, 8, %g4
                               <== NOT EXECUTED
    uint16_t v = b;
                                                  
40039104:	82 10 00 03 	mov  %g3, %g1
                                 <== NOT EXECUTED
40039108:	ba 10 20 08 	mov  8, %i5
                                   <== NOT EXECUTED
4003910c:	84 08 60 01 	and  %g1, 1, %g2
                              <== NOT EXECUTED
40039110:	83 28 60 10 	sll  %g1, 0x10, %g1
                           <== NOT EXECUTED
      v = v & 1 ? (v >> 1) ^ pattern : v >> 1;
                       
40039114:	80 a0 a0 00 	cmp  %g2, 0
                                   <== NOT EXECUTED
40039118:	85 30 60 11 	srl  %g1, 0x11, %g2
                           <== NOT EXECUTED
4003911c:	02 80 00 03 	be  40039128 <rtems_nvdisk_initialize+0x68>
   <== NOT EXECUTED
40039120:	82 10 00 02 	mov  %g2, %g1
                                 <== NOT EXECUTED
40039124:	82 18 80 04 	xor  %g2, %g4, %g1
                            <== NOT EXECUTED
    for (i = 8; i--;)
                                                
40039128:	ba 87 7f ff 	addcc  %i5, -1, %i5
                           <== NOT EXECUTED
4003912c:	12 bf ff f9 	bne  40039110 <rtems_nvdisk_initialize+0x50>
  <== NOT EXECUTED
40039130:	84 08 60 01 	and  %g1, 1, %g2
                              <== NOT EXECUTED
    rtems_nvdisk_crc16_factor[b] = v & 0xffff;
                       
40039134:	85 28 e0 01 	sll  %g3, 1, %g2
                              <== NOT EXECUTED
  for (b = 0; b < 256; b++)
                                          
40039138:	86 00 e0 01 	inc  %g3
                                      <== NOT EXECUTED
4003913c:	80 a0 e1 00 	cmp  %g3, 0x100
                               <== NOT EXECUTED
40039140:	12 bf ff f1 	bne  40039104 <rtems_nvdisk_initialize+0x44>
  <== NOT EXECUTED
40039144:	c2 32 00 02 	sth  %g1, [ %o0 + %g2 ]
                       <== NOT EXECUTED
  rtems_nvdisks = calloc (rtems_nvdisk_configuration_size,
           
40039148:	23 10 02 2e 	sethi  %hi(0x4008b800), %l1
                   <== NOT EXECUTED
4003914c:	e8 04 60 e0 	ld  [ %l1 + 0xe0 ], %l4	! 4008b8e0 <rtems_nvdisk_configuration_size>
<== NOT EXECUTED
40039150:	92 10 20 38 	mov  0x38, %o1
                                <== NOT EXECUTED
40039154:	90 10 00 14 	mov  %l4, %o0
                                 <== NOT EXECUTED
40039158:	7f ff 44 aa 	call  4000a400 <calloc>
                       <== NOT EXECUTED
4003915c:	25 10 02 40 	sethi  %hi(0x40090000), %l2
                   <== NOT EXECUTED
  if (!rtems_nvdisks)
                                                
40039160:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
40039164:	02 80 00 62 	be  400392ec <rtems_nvdisk_initialize+0x22c>
  <== NOT EXECUTED
40039168:	d0 24 a2 40 	st  %o0, [ %l2 + 0x240 ]
                      <== NOT EXECUTED
  for (minor = 0; minor < rtems_nvdisk_configuration_size; minor++, c++)

4003916c:	80 a5 20 00 	cmp  %l4, 0
                                   <== NOT EXECUTED
40039170:	02 80 00 68 	be  40039310 <rtems_nvdisk_initialize+0x250>
  <== NOT EXECUTED
40039174:	2b 10 01 f1 	sethi  %hi(0x4007c400), %l5
                   <== NOT EXECUTED
    char     name[] = RTEMS_NVDISK_DEVICE_BASE_NAME "a";
             
40039178:	21 00 00 18 	sethi  %hi(0x6000), %l0
                       <== NOT EXECUTED
    sc = rtems_disk_create_phys(dev, c->block_size, blocks,
          
4003917c:	33 10 00 e2 	sethi  %hi(0x40038800), %i1
                   <== NOT EXECUTED
	*_mutex = _init;
                                                    
40039180:	39 10 02 07 	sethi  %hi(0x40081c00), %i4
                   <== NOT EXECUTED
  const rtems_nvdisk_config* c = rtems_nvdisk_configuration;
         
40039184:	aa 15 61 bc 	or  %l5, 0x1bc, %l5
                           <== NOT EXECUTED
  for (minor = 0; minor < rtems_nvdisk_configuration_size; minor++, c++)

40039188:	ac 10 20 00 	clr  %l6
                                      <== NOT EXECUTED
    char     name[] = RTEMS_NVDISK_DEVICE_BASE_NAME "a";
             
4003918c:	a0 14 21 00 	or  %l0, 0x100, %l0
                           <== NOT EXECUTED
    sc = rtems_disk_create_phys(dev, c->block_size, blocks,
          
40039190:	a6 07 bf f0 	add  %fp, -16, %l3
                            <== NOT EXECUTED
40039194:	b2 16 63 00 	or  %i1, 0x300, %i1
                           <== NOT EXECUTED
40039198:	b8 17 22 28 	or  %i4, 0x228, %i4
                           <== NOT EXECUTED
    char     name[] = RTEMS_NVDISK_DEVICE_BASE_NAME "a";
             
4003919c:	e0 37 bf f8 	sth  %l0, [ %fp + -8 ]
                        <== NOT EXECUTED
400391a0:	05 0b d9 19 	sethi  %hi(0x2f646400), %g2
                   <== NOT EXECUTED
    name [sizeof(RTEMS_NVDISK_DEVICE_BASE_NAME)] += minor;
           
400391a4:	ec 2f bf f9 	stb  %l6, [ %fp + -7 ]
                        <== NOT EXECUTED
    char     name[] = RTEMS_NVDISK_DEVICE_BASE_NAME "a";
             
400391a8:	84 10 a1 76 	or  %g2, 0x176, %g2
                           <== NOT EXECUTED
400391ac:	07 0b db 9d 	sethi  %hi(0x2f6e7400), %g3
                   <== NOT EXECUTED
400391b0:	86 10 e2 64 	or  %g3, 0x264, %g3	! 2f6e7664 <RAM_SIZE+0x2f2e7664>
<== NOT EXECUTED
400391b4:	c4 3f bf f0 	std  %g2, [ %fp + -16 ]
                       <== NOT EXECUTED
    nvd = &rtems_nvdisks[minor];
                                     
400391b8:	a8 02 00 1d 	add  %o0, %i5, %l4
                            <== NOT EXECUTED
    nvd->major        = major;
                                       
400391bc:	f0 22 00 1d 	st  %i0, [ %o0 + %i5 ]
                        <== NOT EXECUTED
    nvd->devices = calloc (c->device_count, sizeof (rtems_nvdisk_device_ctl));

400391c0:	92 10 20 14 	mov  0x14, %o1
                                <== NOT EXECUTED
    nvd->minor        = minor;
                                       
400391c4:	ec 25 20 04 	st  %l6, [ %l4 + 4 ]
                          <== NOT EXECUTED
    nvd->flags        = c->flags;
                                    
400391c8:	c2 05 60 0c 	ld  [ %l5 + 0xc ], %g1
                        <== NOT EXECUTED
400391cc:	c2 25 20 08 	st  %g1, [ %l4 + 8 ]
                          <== NOT EXECUTED
    nvd->block_size   = c->block_size;
                               
400391d0:	ee 05 40 00 	ld  [ %l5 ], %l7
                              <== NOT EXECUTED
400391d4:	ee 25 20 0c 	st  %l7, [ %l4 + 0xc ]
                        <== NOT EXECUTED
    nvd->info_level   = c->info_level;
                               
400391d8:	c2 05 60 10 	ld  [ %l5 + 0x10 ], %g1
                       <== NOT EXECUTED
400391dc:	c2 25 20 34 	st  %g1, [ %l4 + 0x34 ]
                       <== NOT EXECUTED
    nvd->devices = calloc (c->device_count, sizeof (rtems_nvdisk_device_ctl));

400391e0:	f6 05 60 04 	ld  [ %l5 + 4 ], %i3
                          <== NOT EXECUTED
400391e4:	7f ff 44 87 	call  4000a400 <calloc>
                       <== NOT EXECUTED
400391e8:	90 10 00 1b 	mov  %i3, %o0
                                 <== NOT EXECUTED
    if (!nvd->devices)
                                               
400391ec:	80 a2 20 00 	cmp  %o0, 0
                                   <== NOT EXECUTED
400391f0:	02 80 00 3f 	be  400392ec <rtems_nvdisk_initialize+0x22c>
  <== NOT EXECUTED
400391f4:	d0 25 20 14 	st  %o0, [ %l4 + 0x14 ]
                       <== NOT EXECUTED
    for (device = 0; device < c->device_count; device++)
             
400391f8:	80 a6 e0 00 	cmp  %i3, 0
                                   <== NOT EXECUTED
400391fc:	02 80 00 3f 	be  400392f8 <rtems_nvdisk_initialize+0x238>
  <== NOT EXECUTED
40039200:	9e 10 20 00 	clr  %o7
                                      <== NOT EXECUTED
40039204:	c4 05 60 08 	ld  [ %l5 + 8 ], %g2
                          <== NOT EXECUTED
    uint32_t blocks = 0;
                                             
40039208:	96 10 20 00 	clr  %o3
                                      <== NOT EXECUTED
      dc->device     = device;
                                       
4003920c:	de 22 00 00 	st  %o7, [ %o0 ]
                              <== NOT EXECUTED
    for (device = 0; device < c->device_count; device++)
             
40039210:	9e 03 e0 01 	inc  %o7
                                      <== NOT EXECUTED
  return dd->size / nvd->block_size;
                                 
40039214:	c2 00 a0 08 	ld  [ %g2 + 8 ], %g1
                          <== NOT EXECUTED
40039218:	81 80 20 00 	wr  %g0, %y
                                   <== NOT EXECUTED
4003921c:	c6 05 20 0c 	ld  [ %l4 + 0xc ], %g3
                        <== NOT EXECUTED
40039220:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
40039224:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
40039228:	86 70 40 03 	udiv  %g1, %g3, %g3
                           <== NOT EXECUTED
      dc->pages      = rtems_nvdisk_pages_in_device (nvd, &c->devices[device]);

4003922c:	c6 22 20 04 	st  %g3, [ %o0 + 4 ]
                          <== NOT EXECUTED
    for (device = 0; device < c->device_count; device++)
             
40039230:	80 a6 c0 0f 	cmp  %i3, %o7
                                 <== NOT EXECUTED
40039234:	d8 05 20 0c 	ld  [ %l4 + 0xc ], %o4
                        <== NOT EXECUTED
  return dd->size / nvd->block_size;
                                 
40039238:	81 80 20 00 	wr  %g0, %y
                                   <== NOT EXECUTED
4003923c:	c2 00 a0 08 	ld  [ %g2 + 8 ], %g1
                          <== NOT EXECUTED
40039240:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
40039244:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
40039248:	82 70 40 0c 	udiv  %g1, %o4, %g1
                           <== NOT EXECUTED
  uint32_t bytes = pages * sizeof (uint16_t);
                        
4003924c:	83 28 60 01 	sll  %g1, 1, %g1
                              <== NOT EXECUTED
  return ((bytes - 1) / nvd->block_size) + 1;
                        
40039250:	82 00 7f ff 	add  %g1, -1, %g1
                             <== NOT EXECUTED
      dc->block_base = blocks;
                                       
40039254:	d6 22 20 0c 	st  %o3, [ %o0 + 0xc ]
                        <== NOT EXECUTED
  return ((bytes - 1) / nvd->block_size) + 1;
                        
40039258:	81 80 20 00 	wr  %g0, %y
                                   <== NOT EXECUTED
4003925c:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
40039260:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
40039264:	01 00 00 00 	nop 
                                          <== NOT EXECUTED
40039268:	9a 70 40 0c 	udiv  %g1, %o4, %o5
                           <== NOT EXECUTED
      dc->descriptor = &c->devices[device];
                          
4003926c:	c4 22 20 10 	st  %g2, [ %o0 + 0x10 ]
                       <== NOT EXECUTED
  return ((bytes - 1) / nvd->block_size) + 1;
                        
40039270:	82 03 60 01 	add  %o5, 1, %g1
                              <== NOT EXECUTED
      dc->pages_desc = rtems_nvdisk_page_desc_pages (nvd, &c->devices[device]);

40039274:	c2 22 20 08 	st  %g1, [ %o0 + 8 ]
                          <== NOT EXECUTED
      blocks += dc->pages - dc->pages_desc;
                          
40039278:	86 20 c0 01 	sub  %g3, %g1, %g3
                            <== NOT EXECUTED
4003927c:	90 02 20 14 	add  %o0, 0x14, %o0
                           <== NOT EXECUTED
40039280:	96 02 c0 03 	add  %o3, %g3, %o3
                            <== NOT EXECUTED
    for (device = 0; device < c->device_count; device++)
             
40039284:	12 bf ff e2 	bne  4003920c <rtems_nvdisk_initialize+0x14c>
 <== NOT EXECUTED
40039288:	84 00 a0 10 	add  %g2, 0x10, %g2
                           <== NOT EXECUTED
    nvd->block_count  = blocks;
                                      
4003928c:	d6 25 20 10 	st  %o3, [ %l4 + 0x10 ]
                       <== NOT EXECUTED
    sc = rtems_disk_create_phys(dev, c->block_size, blocks,
          
40039290:	94 10 00 17 	mov  %l7, %o2
                                 <== NOT EXECUTED
    nvd->device_count = c->device_count;
                             
40039294:	f6 25 20 18 	st  %i3, [ %l4 + 0x18 ]
                       <== NOT EXECUTED
    sc = rtems_disk_create_phys(dev, c->block_size, blocks,
          
40039298:	9a 10 20 00 	clr  %o5
                                      <== NOT EXECUTED
4003929c:	e6 23 a0 5c 	st  %l3, [ %sp + 0x5c ]
                       <== NOT EXECUTED
400392a0:	98 10 00 19 	mov  %i1, %o4
                                 <== NOT EXECUTED
400392a4:	90 10 00 18 	mov  %i0, %o0
                                 <== NOT EXECUTED
400392a8:	7f ff 3d 11 	call  400086ec <rtems_disk_create_phys>
       <== NOT EXECUTED
400392ac:	92 10 00 16 	mov  %l6, %o1
                                 <== NOT EXECUTED
    if (sc != RTEMS_SUCCESSFUL)
                                      
400392b0:	ae 92 20 00 	orcc  %o0, 0, %l7
                             <== NOT EXECUTED
400392b4:	12 80 00 13 	bne  40039300 <rtems_nvdisk_initialize+0x240>
 <== NOT EXECUTED
400392b8:	ac 05 a0 01 	inc  %l6
                                      <== NOT EXECUTED
400392bc:	c0 25 20 20 	clr  [ %l4 + 0x20 ]
                           <== NOT EXECUTED
400392c0:	c0 25 20 24 	clr  [ %l4 + 0x24 ]
                           <== NOT EXECUTED
  for (minor = 0; minor < rtems_nvdisk_configuration_size; minor++, c++)

400392c4:	aa 05 60 14 	add  %l5, 0x14, %l5
                           <== NOT EXECUTED
400392c8:	c0 25 20 28 	clr  [ %l4 + 0x28 ]
                           <== NOT EXECUTED
400392cc:	c0 25 20 2c 	clr  [ %l4 + 0x2c ]
                           <== NOT EXECUTED
400392d0:	f8 25 20 30 	st  %i4, [ %l4 + 0x30 ]
                       <== NOT EXECUTED
400392d4:	e8 04 60 e0 	ld  [ %l1 + 0xe0 ], %l4
                       <== NOT EXECUTED
400392d8:	80 a5 00 16 	cmp  %l4, %l6
                                 <== NOT EXECUTED
400392dc:	08 80 00 0d 	bleu  40039310 <rtems_nvdisk_initialize+0x250>
<== NOT EXECUTED
400392e0:	ba 07 60 38 	add  %i5, 0x38, %i5
                           <== NOT EXECUTED
400392e4:	10 bf ff ae 	b  4003919c <rtems_nvdisk_initialize+0xdc>
    <== NOT EXECUTED
400392e8:	d0 04 a2 40 	ld  [ %l2 + 0x240 ], %o0
                      <== NOT EXECUTED
      return RTEMS_NO_MEMORY;
                                        
400392ec:	ae 10 20 1a 	mov  0x1a, %l7
                                <== NOT EXECUTED
}
                                                                    
400392f0:	81 c7 e0 08 	ret 
                                          <== NOT EXECUTED
400392f4:	91 e8 00 17 	restore  %g0, %l7, %o0
                        <== NOT EXECUTED
    uint32_t blocks = 0;
                                             
400392f8:	10 bf ff e5 	b  4003928c <rtems_nvdisk_initialize+0x1cc>
   <== NOT EXECUTED
400392fc:	96 10 20 00 	clr  %o3
                                      <== NOT EXECUTED
      rtems_nvdisk_error ("disk create phy failed");
                 
40039300:	11 10 02 07 	sethi  %hi(0x40081c00), %o0
                   <== NOT EXECUTED
40039304:	7f ff fd b9 	call  400389e8 <rtems_nvdisk_error>
           <== NOT EXECUTED
40039308:	90 12 22 10 	or  %o0, 0x210, %o0	! 40081e10 <msdos_ops+0xdc>
<== NOT EXECUTED
      return sc;
                                                     
4003930c:	30 bf ff 73 	b,a   400390d8 <rtems_nvdisk_initialize+0x18>
 <== NOT EXECUTED
  rtems_nvdisk_count = rtems_nvdisk_configuration_size;
              
40039310:	03 10 02 40 	sethi  %hi(0x40090000), %g1
                   <== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
                                           
40039314:	ae 10 20 00 	clr  %l7
                                      <== NOT EXECUTED
40039318:	10 bf ff 70 	b  400390d8 <rtems_nvdisk_initialize+0x18>
    <== NOT EXECUTED
4003931c:	e8 20 62 3c 	st  %l4, [ %g1 + 0x23c ]
                      <== NOT EXECUTED

                                                                     
===============================================================================
40081e30 <rtems_nvdisk_sram_handlers>:
                               
40081e30:	40 03 93 70 40 03 93 50 40 03 93 20 00 00 00 00     @..p@..P@.. ....

40081e40:	6f 70 74 69 6f 6e 73 3d 25 73 0a 00 00 00 00 00     options=%s......

40081e50:	68 6f 6c 64 2d 62 69 74 6d 61 70 73 00 00 00 00     hold-bitmaps....

40081e60:	6e 6f 2d 6c 6f 63 61 6c 2d 63 61 63 68 65 00 00     no-local-cache..

40081e70:	6d 61 78 2d 68 65 6c 64 2d 62 75 66 73 00 00 00     max-held-bufs...