Diff for /qemu/block.c between versions 1.1.1.1 and 1.1.1.2

version 1.1.1.1, 2018/04/24 16:37:52 version 1.1.1.2, 2018/04/24 16:38:32
Line 32 Line 32
 #include <sys/disk.h>  #include <sys/disk.h>
 #endif  #endif
   
   #ifdef CONFIG_COCOA
   #include <paths.h>
   #include <sys/param.h>
   #include <IOKit/IOKitLib.h>
   #include <IOKit/IOBSD.h>
   #include <IOKit/storage/IOMediaBSDClient.h>
   #include <IOKit/storage/IOMedia.h>
   #include <IOKit/storage/IOCDMedia.h>
   //#include <IOKit/storage/IOCDTypes.h>
   #include <CoreFoundation/CoreFoundation.h>
   #endif
   
 static BlockDriverState *bdrv_first;  static BlockDriverState *bdrv_first;
 static BlockDriver *first_drv;  static BlockDriver *first_drv;
   
   #ifdef CONFIG_COCOA
   static kern_return_t FindEjectableCDMedia( io_iterator_t *mediaIterator );
   static kern_return_t GetBSDPath( io_iterator_t mediaIterator, char *bsdPath, CFIndex maxPathSize );
   
   kern_return_t FindEjectableCDMedia( io_iterator_t *mediaIterator )
   {
       kern_return_t       kernResult; 
       mach_port_t     masterPort;
       CFMutableDictionaryRef  classesToMatch;
   
       kernResult = IOMasterPort( MACH_PORT_NULL, &masterPort );
       if ( KERN_SUCCESS != kernResult ) {
           printf( "IOMasterPort returned %d\n", kernResult );
       }
       
       classesToMatch = IOServiceMatching( kIOCDMediaClass ); 
       if ( classesToMatch == NULL ) {
           printf( "IOServiceMatching returned a NULL dictionary.\n" );
       } else {
       CFDictionarySetValue( classesToMatch, CFSTR( kIOMediaEjectableKey ), kCFBooleanTrue );
       }
       kernResult = IOServiceGetMatchingServices( masterPort, classesToMatch, mediaIterator );
       if ( KERN_SUCCESS != kernResult )
       {
           printf( "IOServiceGetMatchingServices returned %d\n", kernResult );
       }
       
       return kernResult;
   }
   
   kern_return_t GetBSDPath( io_iterator_t mediaIterator, char *bsdPath, CFIndex maxPathSize )
   {
       io_object_t     nextMedia;
       kern_return_t   kernResult = KERN_FAILURE;
       *bsdPath = '\0';
       nextMedia = IOIteratorNext( mediaIterator );
       if ( nextMedia )
       {
           CFTypeRef   bsdPathAsCFString;
       bsdPathAsCFString = IORegistryEntryCreateCFProperty( nextMedia, CFSTR( kIOBSDNameKey ), kCFAllocatorDefault, 0 );
           if ( bsdPathAsCFString ) {
               size_t devPathLength;
               strcpy( bsdPath, _PATH_DEV );
               strcat( bsdPath, "r" );
               devPathLength = strlen( bsdPath );
               if ( CFStringGetCString( bsdPathAsCFString, bsdPath + devPathLength, maxPathSize - devPathLength, kCFStringEncodingASCII ) ) {
                   kernResult = KERN_SUCCESS;
               }
               CFRelease( bsdPathAsCFString );
           }
           IOObjectRelease( nextMedia );
       }
       
       return kernResult;
   }
   
   #endif
   
 void bdrv_register(BlockDriver *bdrv)  void bdrv_register(BlockDriver *bdrv)
 {  {
     bdrv->next = first_drv;      bdrv->next = first_drv;
Line 80  int bdrv_create(BlockDriver *drv,  Line 150  int bdrv_create(BlockDriver *drv, 
 }  }
   
 #ifdef _WIN32  #ifdef _WIN32
 static void get_tmp_filename(char *filename, int size)  void get_tmp_filename(char *filename, int size)
 {  {
       char* p = strrchr(filename, '/');
   
       if (p == NULL)
           return;
   
     /* XXX: find a better function */      /* XXX: find a better function */
     tmpnam(filename);      tmpnam(p);
       *p = '/';
 }  }
 #else  #else
 static void get_tmp_filename(char *filename, int size)  void get_tmp_filename(char *filename, int size)
 {  {
     int fd;      int fd;
     /* XXX: race condition possible */      /* XXX: race condition possible */
Line 118  static BlockDriver *find_image_format(co Line 194  static BlockDriver *find_image_format(co
                 bufsize = sectorsize;                  bufsize = sectorsize;
         }          }
 #endif  #endif
   #ifdef CONFIG_COCOA
           u_int32_t   blockSize = 512;
           if ( !ioctl( fd, DKIOCGETBLOCKSIZE, &blockSize ) && blockSize > bufsize) {
               bufsize = blockSize;
           }
   #endif
         buf = qemu_malloc(bufsize);          buf = qemu_malloc(bufsize);
         if (!buf)          if (!buf)
             return NULL;              return NULL;
Line 145  static BlockDriver *find_image_format(co Line 227  static BlockDriver *find_image_format(co
   
 int bdrv_open(BlockDriverState *bs, const char *filename, int snapshot)  int bdrv_open(BlockDriverState *bs, const char *filename, int snapshot)
 {  {
   #ifdef CONFIG_COCOA
       if ( strncmp( filename, "/dev/cdrom", 10 ) == 0 ) {
           kern_return_t kernResult;
           io_iterator_t mediaIterator;
           char bsdPath[ MAXPATHLEN ];
           int fd;
    
           kernResult = FindEjectableCDMedia( &mediaIterator );
           kernResult = GetBSDPath( mediaIterator, bsdPath, sizeof( bsdPath ) );
       
           if ( bsdPath[ 0 ] != '\0' ) {
               strcat(bsdPath,"s0");
               /* some CDs don't have a partition 0 */
               fd = open(bsdPath, O_RDONLY | O_BINARY | O_LARGEFILE);
               if (fd < 0) {
                   bsdPath[strlen(bsdPath)-1] = '1';
               } else {
                   close(fd);
               }
               filename = bsdPath;
           }
           
           if ( mediaIterator )
               IOObjectRelease( mediaIterator );
       }
   #endif
     return bdrv_open2(bs, filename, snapshot, NULL);      return bdrv_open2(bs, filename, snapshot, NULL);
 }  }
   
Line 292  int bdrv_commit(BlockDriverState *bs) Line 400  int bdrv_commit(BlockDriverState *bs)
             i += n;              i += n;
         }          }
     }      }
   
       if (bs->drv->bdrv_make_empty)
           return bs->drv->bdrv_make_empty(bs);
   
     return 0;      return 0;
 }  }
   
Line 342  int bdrv_write(BlockDriverState *bs, int Line 454  int bdrv_write(BlockDriverState *bs, int
         return -1;          return -1;
     if (bs->read_only)      if (bs->read_only)
         return -1;          return -1;
       if (sector_num == 0 && bs->boot_sector_enabled && nb_sectors > 0) {
           memcpy(bs->boot_sector_data, buf, 512);   
       }
     return bs->drv->bdrv_write(bs, sector_num, buf, nb_sectors);      return bs->drv->bdrv_write(bs, sector_num, buf, nb_sectors);
 }  }
   
Line 567  static int raw_open(BlockDriverState *bs Line 682  static int raw_open(BlockDriverState *bs
 #ifdef DIOCGMEDIASIZE  #ifdef DIOCGMEDIASIZE
         if (ioctl(fd, DIOCGMEDIASIZE, (off_t *)&size))          if (ioctl(fd, DIOCGMEDIASIZE, (off_t *)&size))
 #endif  #endif
             size = lseek(fd, 0LL, SEEK_END);  #ifdef CONFIG_COCOA
           size = LONG_LONG_MAX;
   #else
           size = lseek(fd, 0LL, SEEK_END);
   #endif
     } else      } else
 #endif  #endif
     {      {

Removed from v.1.1.1.1  
changed lines
  Added in v.1.1.1.2


unix.superglobalmegacorp.com