Merge pull request #187 from utmapp/aarch64-virt

Extend support for aarch64 with more configuration options

Author: osy

Configuration/UTMConfiguration.h

@@ -16,6 +16,16 @@
 
 #import <Foundation/Foundation.h>
 
+typedef NS_ENUM(NSUInteger, UTMDiskImageType) {
+    UTMDiskImageTypeDisk,
+    UTMDiskImageTypeCD,
+    UTMDiskImageTypeBIOS,
+    UTMDiskImageTypeKernel,
+    UTMDiskImageTypeInitrd,
+    UTMDiskImageTypeDTB,
+    UTMDiskImageTypeMax
+};
+
 NS_ASSUME_NONNULL_BEGIN
 
 @interface UTMConfiguration : NSObject
@@ -26,6 +36,8 @@ NS_ASSUME_NONNULL_BEGIN
 + (NSArray<NSString *>*)supportedArchitectures;
 + (NSArray<NSString *>*)supportedBootDevicesPretty;
 + (NSArray<NSString *>*)supportedBootDevices;
++ (NSArray<NSString *>*)supportedImageTypesPretty;
++ (NSArray<NSString *>*)supportedImageTypes;
 + (NSArray<NSString *>*)supportedSoundCardDevices;
 + (NSArray<NSString *>*)supportedSoundCardDevicesPretty;
 + (NSArray<NSString *>*)supportedTargetsForArchitecture:(NSString *)architecture;
@@ -85,13 +97,13 @@ NS_ASSUME_NONNULL_BEGIN
 - (NSArray *)systemArguments;
 
 - (NSUInteger)countDrives;
-- (NSUInteger)newDrive:(NSString *)name interface:(NSString *)interface isCdrom:(BOOL)isCdrom;
+- (NSUInteger)newDrive:(NSString *)name type:(UTMDiskImageType)type interface:(NSString *)interface;
 - (nullable NSString *)driveImagePathForIndex:(NSUInteger)index;
 - (void)setImagePath:(NSString *)path forIndex:(NSUInteger)index;
 - (nullable NSString *)driveInterfaceTypeForIndex:(NSUInteger)index;
 - (void)setDriveInterfaceType:(NSString *)interfaceType forIndex:(NSUInteger)index;
-- (BOOL)driveIsCdromForIndex:(NSUInteger)index;
-- (void)setDriveIsCdrom:(BOOL)isCdrom forIndex:(NSUInteger)index;
+- (UTMDiskImageType)driveImageTypeForIndex:(NSUInteger)index;
+- (void)setDriveImageType:(UTMDiskImageType)type forIndex:(NSUInteger)index;
 - (void)moveDriveIndex:(NSUInteger)index to:(NSUInteger)newIndex;
 - (void)removeDriveAtIndex:(NSUInteger)index;
 

Configuration/UTMConfiguration.m

@@ -58,6 +58,7 @@
 const NSString *const kUTMConfigChipboardSharingKey = @"ClipboardSharing";
 
 const NSString *const kUTMConfigImagePathKey = @"ImagePath";
+const NSString *const kUTMConfigImageTypeKey = @"ImageType";
 const NSString *const kUTMConfigInterfaceTypeKey = @"InterfaceType";
 const NSString *const kUTMConfigCdromKey = @"Cdrom";
 
@@ -195,6 +196,28 @@ @implementation UTMConfiguration {
              ];
 }
 
++ (NSArray<NSString *>*)supportedImageTypesPretty {
+    return @[
+             NSLocalizedString(@"Disk Image", "UTMConfiguration"),
+             NSLocalizedString(@"CD/DVD Image", "UTMConfiguration"),
+             NSLocalizedString(@"BIOS", "UTMConfiguration"),
+             NSLocalizedString(@"Linux Kernel", "UTMConfiguration"),
+             NSLocalizedString(@"Linux RAM Disk", "UTMConfiguration"),
+             NSLocalizedString(@"Linux Device Tree Binary", "UTMConfiguration")
+             ];
+}
+
++ (NSArray<NSString *>*)supportedImageTypes {
+    return @[
+             @"disk",
+             @"cd",
+             @"bios",
+             @"kernel",
+             @"initrd",
+             @"dtb"
+             ];
+}
+
 + (NSArray<NSString *>*)supportedTargetsForArchitecture:(NSString *)architecture {
     return @{
         @"alpha":
@@ -1328,6 +1351,17 @@ - (void)migrateConfigurationIfNecessary {
     if (!_rootDict[kUTMConfigSoundKey][kUTMConfigSoundCardDeviceKey]) {
         _rootDict[kUTMConfigSoundKey][kUTMConfigSoundCardDeviceKey] = [UTMConfiguration supportedSoundCardDevices][0];
     }
+    // Migrate Cdrom => ImageType
+    [_rootDict[kUTMConfigDrivesKey] enumerateObjectsUsingBlock:^(id  _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
+        if (!obj[kUTMConfigImageTypeKey]) {
+            if ([obj[kUTMConfigCdromKey] boolValue]) {
+                [self setDriveImageType:UTMDiskImageTypeCD forIndex:idx];
+            } else {
+                [self setDriveImageType:UTMDiskImageTypeDisk forIndex:idx];
+            }
+            [obj removeObjectForKey:kUTMConfigCdromKey];
+        }
+    }];
 }
 
 #pragma mark - Initialization
@@ -1621,12 +1655,13 @@ - (NSUInteger)countDrives {
     return [_rootDict[kUTMConfigDrivesKey] count];
 }
 
-- (NSUInteger)newDrive:(NSString *)name interface:(NSString *)interface isCdrom:(BOOL)isCdrom {
+- (NSUInteger)newDrive:(NSString *)name type:(UTMDiskImageType)type interface:(NSString *)interface {
     NSUInteger index = [self countDrives];
+    NSString *strType = [UTMConfiguration supportedImageTypes][type];
     NSMutableDictionary *drive = [[NSMutableDictionary alloc] initWithDictionary:@{
                                                                                    kUTMConfigImagePathKey: name,
-                                                                                   kUTMConfigInterfaceTypeKey: interface,
-                                                                                   kUTMConfigCdromKey: @(isCdrom)
+                                                                                   kUTMConfigImageTypeKey: strType,
+                                                                                   kUTMConfigInterfaceTypeKey: interface
                                                                                    }];
     [_rootDict[kUTMConfigDrivesKey] addObject:drive];
     return index;
@@ -1648,12 +1683,19 @@ - (void)setDriveInterfaceType:(NSString *)interfaceType forIndex:(NSUInteger)ind
     _rootDict[kUTMConfigDrivesKey][index][kUTMConfigInterfaceTypeKey] = interfaceType;
 }
 
-- (BOOL)driveIsCdromForIndex:(NSUInteger)index {
-    return [_rootDict[kUTMConfigDrivesKey][index][kUTMConfigCdromKey] boolValue];
+- (UTMDiskImageType)driveImageTypeForIndex:(NSUInteger)index {
+    NSString *strType = _rootDict[kUTMConfigDrivesKey][index][kUTMConfigImageTypeKey];
+    NSUInteger type = [[UTMConfiguration supportedImageTypes] indexOfObject:strType];
+    if (type == NSNotFound || type >= UTMDiskImageTypeMax) {
+        return UTMDiskImageTypeDisk;
+    } else {
+        return (UTMDiskImageType)type;
+    }
 }
 
-- (void)setDriveIsCdrom:(BOOL)isCdrom forIndex:(NSUInteger)index {
-    _rootDict[kUTMConfigDrivesKey][index][kUTMConfigCdromKey] = @(isCdrom);
+- (void)setDriveImageType:(UTMDiskImageType)type forIndex:(NSUInteger)index {
+    NSString *strType = [UTMConfiguration supportedImageTypes][type];
+    _rootDict[kUTMConfigDrivesKey][index][kUTMConfigImageTypeKey] = strType;
 }
 
 - (void)moveDriveIndex:(NSUInteger)index to:(NSUInteger)newIndex {

ConfigurationViews/VMConfigDriveDetailViewController.h

@@ -15,26 +15,35 @@
 //
 
 #import <UIKit/UIKit.h>
+#import "UTMConfiguration.h"
 #import "VMConfigViewController.h"
 
 NS_ASSUME_NONNULL_BEGIN
 
 @interface VMConfigDriveDetailViewController : VMConfigViewController<UIPickerViewDelegate, UIPickerViewDataSource>
 
 @property (weak, nonatomic) IBOutlet UILabel *existingPathLabel;
+
+// image type
+@property (weak, nonatomic) IBOutlet UILabel *imageTypeLabel;
+@property (weak, nonatomic) IBOutlet UITableViewCell *imageTypePickerCell;
+@property (weak, nonatomic) IBOutlet UIPickerView *imageTypePicker;
+@property (weak, nonatomic) IBOutlet UITableViewCell *imageTypeCell;
+@property (nonatomic, assign) BOOL imageTypePickerActive;
+@property (nonatomic, assign) UTMDiskImageType imageType;
+
+// drive location
 @property (weak, nonatomic) IBOutlet UILabel *driveLocationLabel;
 @property (weak, nonatomic) IBOutlet UITableViewCell *driveLocationPickerCell;
 @property (weak, nonatomic) IBOutlet UIPickerView *driveLocationPicker;
 @property (weak, nonatomic) IBOutlet UITableViewCell *driveLocationCell;
 @property (nonatomic, assign) BOOL driveLocationPickerActive;
-@property (strong, nonatomic) IBOutletCollection(UITableViewCell) NSArray *existingImageCells;
+@property (nonatomic, nullable, strong) NSString *driveInterfaceType;
+
 @property (weak, nonatomic) IBOutlet UISwitch *isCdromSwitch;
 @property (nonatomic, assign) NSUInteger driveIndex;
-@property (nonatomic, nullable, strong) NSString *driveInterfaceType;
 @property (nonatomic, assign) BOOL valid;
 
-- (IBAction)isCdromSwitchChanged:(UISwitch *)sender;
-
 @end
 
 NS_ASSUME_NONNULL_END

ConfigurationViews/VMConfigDriveDetailViewController.m

@@ -35,18 +35,40 @@ - (void)viewWillAppear:(BOOL)animated {
 
 - (void)refreshViewFromConfiguration {
     [super refreshViewFromConfiguration];
+    self.imageTypePickerActive = NO;
     self.driveLocationPickerActive = NO;
     if (self.valid) {
         self.existingPathLabel.text = [self.configuration driveImagePathForIndex:self.driveIndex];
-        self.isCdromSwitch.on = [self.configuration driveIsCdromForIndex:self.driveIndex];
+        self.imageType = [self.configuration driveImageTypeForIndex:self.driveIndex];
         self.driveInterfaceType = [self.configuration driveInterfaceTypeForIndex:self.driveIndex];
     } else {
+        self.imageType = UTMDiskImageTypeDisk;
         self.driveInterfaceType = [UTMConfiguration defaultDriveInterface];
     }
 }
 
 #pragma mark - Properties
 
+- (void)setImageTypePickerActive:(BOOL)imageTypePickerActive  {
+    _imageTypePickerActive = imageTypePickerActive;
+    [self pickerCell:self.imageTypePickerCell setActive:imageTypePickerActive];
+}
+
+- (void)setImageType:(UTMDiskImageType)imageType {
+    NSAssert(imageType < UTMDiskImageTypeMax, @"Invalid image type %lu", imageType);
+    _imageType = imageType;
+    if (self.valid) {
+        [self.configuration setDriveImageType:imageType forIndex:self.driveIndex];
+    }
+    self.imageTypeLabel.text = [UTMConfiguration supportedImageTypes][imageType];
+    if (imageType == UTMDiskImageTypeDisk || imageType == UTMDiskImageTypeCD) {
+        [self pickerCell:self.driveLocationCell setActive:YES];
+    } else {
+        [self pickerCell:self.driveLocationCell setActive:NO];
+        self.driveLocationPickerActive = NO;
+    }
+}
+
 - (void)setDriveLocationPickerActive:(BOOL)driveLocationPickerActive {
     _driveLocationPickerActive = driveLocationPickerActive;
     [self pickerCell:self.driveLocationPickerCell setActive:driveLocationPickerActive];
@@ -66,6 +88,9 @@ - (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath
     if ([tableView cellForRowAtIndexPath:indexPath] == self.driveLocationCell) {
         self.driveLocationPickerActive = !self.driveLocationPickerActive;
         [tableView deselectRowAtIndexPath:indexPath animated:YES];
+    } else if ([tableView cellForRowAtIndexPath:indexPath] == self.imageTypeCell) {
+        self.imageTypePickerActive = !self.imageTypePickerActive;
+        [tableView deselectRowAtIndexPath:indexPath animated:YES];
     }
 }
 
@@ -74,6 +99,8 @@ - (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath
 - (NSInteger)numberOfComponentsInPickerView:(nonnull UIPickerView *)pickerView {
     if (pickerView == self.driveLocationPicker) {
         return 1;
+    } else if (pickerView == self.imageTypePicker) {
+        return 1;
     } else {
         NSAssert(0, @"Invalid picker");
     }
@@ -84,6 +111,8 @@ - (NSInteger)pickerView:(nonnull UIPickerView *)pickerView numberOfRowsInCompone
     NSAssert(component == 0, @"Invalid component");
     if (pickerView == self.driveLocationPicker) {
         return [UTMConfiguration supportedDriveInterfaces].count;
+    } else if (pickerView == self.imageTypePicker) {
+        return [UTMConfiguration supportedImageTypes].count;
     } else {
         NSAssert(0, @"Invalid picker");
     }
@@ -94,6 +123,8 @@ - (NSString *)pickerView:(UIPickerView *)pickerView titleForRow:(NSInteger)row f
     NSAssert(component == 0, @"Invalid component");
     if (pickerView == self.driveLocationPicker) {
         return [UTMConfiguration supportedDriveInterfaces][row];
+    } else if (pickerView == self.imageTypePicker) {
+        return [UTMConfiguration supportedImageTypesPretty][row];
     } else {
         NSAssert(0, @"Invalid picker");
     }
@@ -104,6 +135,8 @@ - (void)pickerView:(UIPickerView *)pickerView didSelectRow:(NSInteger)row inComp
     NSAssert(component == 0, @"Invalid component");
     if (pickerView == self.driveLocationPicker) {
         self.driveInterfaceType = [UTMConfiguration supportedDriveInterfaces][row];
+    } else if (pickerView == self.imageTypePicker) {
+        self.imageType = row;
     } else {
         NSAssert(0, @"Invalid picker");
     }
@@ -125,19 +158,10 @@ - (IBAction)unwindToDriveDetailFromDrivePicker:(UIStoryboardSegue*)sender {
     VMConfigDrivePickerViewController *source = (VMConfigDrivePickerViewController *)sender.sourceViewController;
     if (!self.valid) {
         self.valid = YES;
-        self.driveIndex = [self.configuration newDrive:source.selectedName interface:self.driveInterfaceType isCdrom:self.isCdromSwitch.on];
+        self.driveIndex = [self.configuration newDrive:source.selectedName type:self.imageType interface:self.driveInterfaceType];
     } else {
         [self.configuration setImagePath:source.selectedName forIndex:self.driveIndex];
     }
 }
 
-#pragma mark - Event handlers
-
-- (IBAction)isCdromSwitchChanged:(UISwitch *)sender {
-    NSAssert(sender == self.isCdromSwitch, @"Invalid sender");
-    if (self.valid) {
-        [self.configuration setDriveIsCdrom:sender.on forIndex:self.driveIndex];
-    }
-}
-
 @end

ConfigurationViews/VMConfigDrivesViewController.m

@@ -57,7 +57,10 @@ - (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(N
     NSAssert(cell, @"Invalid cell");
 
     cell.textLabel.text = [self.configuration driveImagePathForIndex:indexPath.row];
-    cell.detailTextLabel.text = [self.configuration driveInterfaceTypeForIndex:indexPath.row];
+    UTMDiskImageType type = [self.configuration driveImageTypeForIndex:indexPath.row];
+    NSString *typeStr = [UTMConfiguration supportedImageTypesPretty][type];
+    NSString *interface = [self.configuration driveInterfaceTypeForIndex:indexPath.row];
+    cell.detailTextLabel.text = [NSString stringWithFormat:@"%@ - %@", typeStr, interface];
 
     return cell;
 }