public async Task CreateLayout()
{
using (var gpt = await GptContextFactory.Create(3, FileAccess.ReadWrite))
{
gpt.RemoveExisting("SYSTEM");
gpt.RemoveExisting("MSR");
gpt.RemoveExisting("Windows");
gpt.RemoveExisting("Recovery");
}
using (var gpt = await GptContextFactory.Create(3, FileAccess.ReadWrite))
{
gpt.Add(new EntryBuilder("SYSTEM", ByteSize.FromMegaBytes(100), PartitionType.Esp).NoAutoMount().Build());
gpt.Add(new EntryBuilder("MSR", ByteSize.FromMegaBytes(16), PartitionType.Reserved).NoAutoMount().Build());
var windowsSize = gpt.AvailableSize - ByteSize.FromMegaBytes(500);
gpt.Add(new EntryBuilder("Windows", windowsSize, PartitionType.Basic).Build());
gpt.Add(new EntryBuilder("Recovery", ByteSize.FromMegaBytes(500), PartitionType.Recovery)
.NoAutoMount()
.MarkAsCritical()
.Build());
}
}
public async Task CheckRecovery()
{
using (var gpt = await GptContextFactory.Create(3, FileAccess.ReadWrite))
{
var part = gpt.Get("Recovery");
}
}
public async Task <IList <IPartition> > GetPartitions()
{
var results = await PowerShellMixin.ExecuteScript($"Get-Partition -DiskNumber {Number}");
var wmiPartitions = results
.Select(x => x.ImmediateBaseObject)
.Select(ToWmiPartition);
ReadOnlyCollection <Core.FileSystem.Gpt.Partition> gptPartitions;
using (var context = await GptContextFactory.Create(Number, FileAccess.Read))
{
gptPartitions = context.Partitions;
}
var partitions = wmiPartitions
.Join(gptPartitions, x => x.Guid, x => x.Guid, (wmi, gpt) => (IPartition) new Partition(this)
{
Name = gpt.Name,
Root = wmi.Root,
Number = wmi.Number,
Guid = wmi.Guid,
PartitionType = wmi.PartitionType,
UniqueId = wmi.UniqueId,
Size = wmi.Size,
});
return(partitions.ToList());
}
public async Task <List <Partition> > GetPartitions()
{
using (var context = await GptContextFactory.Create(Number, FileAccess.Read))
{
return(context.Partitions.Select(x => x.AsCommon(this)).ToList());
}
}
protected override async Task <bool> IsWoAPresent()
{
var disk = await GetDeviceDisk();
using (var context = await GptContextFactory.Create(disk.Number, FileAccess.Read))
{
return(context.Get(PartitionName.Data) != null && context.Get(PartitionName.System) != null);
}
}
public async Task <bool> IsWindowsPhonePresent()
{
var disk = await GetDeviceDisk();
using (var context = await GptContextFactory.Create(disk.Number, FileAccess.Read))
{
return(context.Get(PartitionName.MainOs) != null && context.Get(PartitionName.Data) != null);
}
}
public async Task <List <Partition> > GetPartitions(Disk disk)
{
Log.Debug("Getting partitions from disk {Disk}", disk);
using (var transaction = await GptContextFactory.Create(disk.Number, FileAccess.Read))
{
var partitions = transaction.Partitions.Select(x => x.AsCommon(disk));
return(partitions.ToList());
}
}
protected override async Task AllocateSpace()
{
var deviceDisk = await Phone.GetDeviceDisk();
using (var context = await GptContextFactory.Create(deviceDisk.Number, FileAccess.ReadWrite))
{
context.RemoveExisting(PartitionName.Data);
context.RemoveExisting(PartitionName.MainOs);
}
}
public async Task RemovePartition(Partition partition)
{
Log.Verbose("Removing {Partition}", partition);
using (var c = await GptContextFactory.Create(partition.Disk.Number, FileAccess.ReadWrite))
{
var gptPart = c.Find(partition.Guid);
c.Delete(gptPart);
}
await partition.Disk.Refresh();
}
private async Task EnsureDataIsLastPartition()
{
Log.Verbose("Ensuring that Data partition is the last partition");
using (var c = await GptContextFactory.Create(disk.Number, FileAccess.Read))
{
var last = c.Partitions.Last();
if (!string.Equals(last.Name, PartitionName.Data, StringComparison.InvariantCultureIgnoreCase))
{
throw new PartitioningException($"The label of the last partition should be '{PartitionName.Data}' and it's '{last.Name}'");
}
}
}
private async Task FormatPartitions()
{
Log.Information("Formatting partitions");
using (var transaction = await GptContextFactory.Create(disk.Number, FileAccess.Read))
{
await transaction.Get(PartitionName.System).AsCommon(disk).Format(FileSystemFormat.Fat32, PartitionName.System);
await transaction.Get(PartitionName.Windows).AsCommon(disk).Format(FileSystemFormat.Ntfs, PartitionName.Windows);
}
await disk.Refresh();
}
public async Task Execute(int diskNumber, string namesList)
{
using (var context = await GptContextFactory.Create((uint)diskNumber, FileAccess.ReadWrite))
{
foreach (var name in namesList.Split(';'))
{
context.RemoveExisting(name);
}
}
var disk = await fileSystem.GetDisk(diskNumber);
await disk.Refresh();
}
private async Task RemoveAnyPartitionsAfterData()
{
Log.Verbose("Removing all the partitions after the Data partition");
using (var c = await GptContextFactory.Create(disk.Number, FileAccess.ReadWrite))
{
var toRemove = GetPartitionsAfterData(c);
foreach (var partition in toRemove)
{
c.Delete(partition);
}
}
}
public async Task Clean(IPhone toClean)
{
Log.Information("Performing cleanup of possible existing deployments");
disk = await toClean.GetDeviceDisk();
using (var context = await GptContextFactory.Create(disk.Number, FileAccess.ReadWrite))
{
context.RemoveExisting(PartitionName.System);
context.RemoveExisting(PartitionName.Reserved);
context.RemoveExisting(PartitionName.Windows);
}
Log.Information("Cleanup done");
await disk.Refresh();
}
private async Task <IEnumerable <PartitionData> > GetGptPartitions()
{
ReadOnlyCollection <Core.FileSystem.Gpt.Partition> gptPartitions;
using (var context = await GptContextFactory.Create(Number, FileAccess.Read))
{
gptPartitions = context.Partitions;
}
var fromGpt = gptPartitions.Select(gpt => new PartitionData
{
Name = gpt.Name,
Guid = gpt.Guid,
}
);
return(fromGpt);
}
public async Task Clean(IPhone toClean)
{
Log.Information("Performing cleanup of possible existing deployments");
disk = await toClean.GetDeviceDisk();
using (var context = await GptContextFactory.Create(disk.Number, FileAccess.ReadWrite))
{
RemoveWellKnownPartitions(context);
// This code is not there because it's considered unsafe. It's here just in case it's useful for a rare case.
// RemovePartitionsAfterData(context);
}
Log.Information("Cleanup done");
await disk.Refresh();
}
public async Task <Partition> GetPartition(string name)
{
return(await Observable.FromAsync(async() =>
{
using (var context = await GptContextFactory.Create(Number, FileAccess.Read))
{
var partition = context.Partitions.First(x =>
string.Equals(x.Name, name, StringComparison.InvariantCultureIgnoreCase));
if (partition == null)
{
throw new ApplicationException($"Cannot find partition named {name} in {this}");
}
return partition.AsCommon(this);
}
}).RetryWithBackoffStrategy());
}
public async Task SetGptType(Partition partition, PartitionType partitionType)
{
Log.Verbose("Setting new GPT partition type {Type} to {Partition}", partitionType, partition);
if (Equals(partition.PartitionType, partitionType))
{
return;
}
using (var context = await GptContextFactory.Create(partition.Disk.Number, FileAccess.ReadWrite, GptContext.DefaultBytesPerSector, GptContext.DefaultChunkSize))
{
var part = context.Find(partition.Guid);
part.PartitionType = partitionType;
}
await partition.Disk.Refresh();
Log.Verbose("New GPT type set correctly", partitionType, partition);
}
private async Task EnsureDataIsLastPartition()
{
Log.Verbose("Ensuring that Data partition is the last partition");
using (var c = await GptContextFactory.Create(disk.Number, FileAccess.Read))
{
var last = c.Partitions.Last();
var asCommon = last.AsCommon(disk);
var volume = await asCommon.GetVolume();
if (volume == null)
{
throw new PartitioningException("Cannot get the volume of the last partition to check its label.");
}
if (!string.Equals(volume.Label, PartitionName.Data, StringComparison.InvariantCultureIgnoreCase))
{
throw new PartitioningException($"The label of the last partition should be '{PartitionName.Data}' and it's '{volume.Label}'");
}
}
}
private async Task RemoveAnyPartitionsAfterData()
{
Log.Verbose("Removing all the partitions after the Data partition");
if (dataPartition == null)
{
Log.Verbose("Data partition not found. The removal of partitions after Data won't be performed");
return;
}
using (var c = await GptContextFactory.Create(disk.Number, FileAccess.ReadWrite))
{
var toRemove = GetPartitionsAfterData(c);
foreach (var partition in toRemove)
{
c.Delete(partition);
}
}
}
private async Task CreatePartitions()
{
Log.Verbose("Creating partitions");
using (var t = await GptContextFactory.Create(disk.Number, FileAccess.ReadWrite))
{
t.Add(new EntryBuilder(PartitionName.System, systemSize, PartitionType.Esp)
.NoAutoMount()
.Build());
t.Add(new EntryBuilder(PartitionName.Reserved, reservedSize, PartitionType.Reserved)
.NoAutoMount()
.Build());
var windowsSize = t.AvailableSize;
t.Add(new EntryBuilder(PartitionName.Windows, windowsSize, PartitionType.Basic)
.NoAutoMount()
.Build());
}
await disk.Refresh();
}
public async Task Execute(int diskNumber)
{
var disk = await fileSystem.GetDisk(diskNumber);
Log.Verbose("Creating partitions");
using (var t = await GptContextFactory.Create((uint)diskNumber, FileAccess.ReadWrite))
{
t.Add(new EntryBuilder("SYSTEM", systemSize, GptType.Esp)
.NoAutoMount()
.Build());
t.Add(new EntryBuilder("MSR", reservedSize, GptType.Reserved)
.NoAutoMount()
.Build());
var windowsSize = t.AvailableSize;
t.Add(new EntryBuilder("Windows", windowsSize, GptType.Basic)
.NoAutoMount()
.Build());
}
await disk.Refresh();
}
