public void BVT_Resize()
{
BaseTestSite.Log.Add(LogEntryKind.TestStep, "1. Client opens a shared virtual disk file and expects success.");
OpenSharedVHD(TestConfig.NameOfSharedVHDS, RSVD_PROTOCOL_VERSION.RSVD_PROTOCOL_VERSION_2);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "2. Client sends the tunnel operation SVHDX_META_OPERATION_START_REQUEST to resize a VHDSet file and expects success.");
SVHDX_META_OPERATION_START_REQUEST startRequest = new SVHDX_META_OPERATION_START_REQUEST();
startRequest.TransactionId = System.Guid.NewGuid();
startRequest.OperationType = Operation_Type.SvhdxMetaOperationTypeResize;
SVHDX_META_OPERATION_RESIZE_VIRTUAL_DISK resizeStructure = new SVHDX_META_OPERATION_RESIZE_VIRTUAL_DISK();
resizeStructure.NewSize = NewSize;
byte[] payload = client.CreateTunnelMetaOperationStartResizeRequest(
startRequest,
resizeStructure);
SVHDX_TUNNEL_OPERATION_HEADER? header;
SVHDX_TUNNEL_OPERATION_HEADER? response;
//For RSVD_TUNNEL_META_OPERATION_START operation code, the IOCTL code should be FSCTL_SVHDX_ASYNC_TUNNEL_REQUEST
uint status = client.TunnelOperation<SVHDX_TUNNEL_OPERATION_HEADER>(
true,//true for Async operation, false for non-async operation
RSVD_TUNNEL_OPERATION_CODE.RSVD_TUNNEL_META_OPERATION_START,
++RequestIdentifier,
payload,
out header,
out response);
BaseTestSite.Assert.AreEqual(
(uint)Smb2Status.STATUS_SUCCESS,
status,
"Ioctl should succeed, actual status: {0}",
GetStatus(status));
VerifyTunnelOperationHeader(header.Value, RSVD_TUNNEL_OPERATION_CODE.RSVD_TUNNEL_META_OPERATION_START, (uint)RsvdStatus.STATUS_SVHDX_SUCCESS, RequestIdentifier);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "3. Client closes the file.");
client.CloseSharedVirtualDisk();
BaseTestSite.Log.Add(LogEntryKind.TestStep, "4. Client reopens the virtual disk file and expects VirtualSize is changed to 2G.");
RequestIdentifier = 0;
Smb2CreateContextResponse[] serverContextResponse;
OpenSharedVHD(TestConfig.NameOfSharedVHDS, RSVD_PROTOCOL_VERSION.RSVD_PROTOCOL_VERSION_2, null, true, null, out serverContextResponse, null);
foreach (var context in serverContextResponse)
{
System.Type type = context.GetType();
if (type.Name == "Smb2CreateSvhdxOpenDeviceContextResponseV2")
{
Smb2CreateSvhdxOpenDeviceContextResponseV2 openDeviceContext = context as Smb2CreateSvhdxOpenDeviceContextResponseV2;
VerifyFieldInResponse("VirtualSize", NewSize, openDeviceContext.VirtualSize);
}
}
client.CloseSharedVirtualDisk();
}
public void BVT_Extract_VHDSet()
{
BaseTestSite.Log.Add(LogEntryKind.TestStep, "1. Client opens a shared virtual disk file and expects success.");
OpenSharedVHD(TestConfig.NameOfSharedVHDS, RSVD_PROTOCOL_VERSION.RSVD_PROTOCOL_VERSION_2);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "2. Client sends tunnel operation SVHDX_META_OPERATION_START_REQUEST to server and expects success.");
System.Guid snapshotId = System.Guid.NewGuid();
CreateSnapshot(snapshotId);
SVHDX_META_OPERATION_START_REQUEST startRequest = new SVHDX_META_OPERATION_START_REQUEST();
startRequest.TransactionId = System.Guid.NewGuid();
startRequest.OperationType = Operation_Type.SvhdxMetaOperationTypeExtractVHD;
SVHDX_META_OPERATION_EXTRACT extract = new SVHDX_META_OPERATION_EXTRACT();
extract.snapshotType = Snapshot_Type.SvhdxSnapshotTypeVM;
extract.flags = ExtractSnapshot_Flags.SVHDX_EXTRACT_SNAPSHOTS_FLAG_ZERO;
extract.SourceSnapshotId = snapshotId;
//Zero indicates that there MUST be no base snapshot and that the extracted disk will not be a differencing VHD.
extract.SourceLimitSnapshotId = System.Guid.Empty;
extract.DestinationFileName = Encoding.Unicode.GetBytes(System.Guid.NewGuid().ToString() + "\0");
extract.DestinationFileNameLength = (uint)extract.DestinationFileName.Length;
byte[] payload = client.CreateTunnelMetaOperationStartExtractRequest(
startRequest,
extract);
SVHDX_TUNNEL_OPERATION_HEADER? header;
SVHDX_TUNNEL_OPERATION_HEADER? response;
//For RSVD_TUNNEL_META_OPERATION_START operation code, the IOCTL code should be FSCTL_SVHDX_ASYNC_TUNNEL_REQUEST
uint status = client.TunnelOperation<SVHDX_TUNNEL_OPERATION_HEADER>(
true, //true for Async operation, false for non-async operation
RSVD_TUNNEL_OPERATION_CODE.RSVD_TUNNEL_META_OPERATION_START,
++RequestIdentifier,
payload,
out header,
out response);
BaseTestSite.Assert.AreEqual(
(uint)Smb2Status.STATUS_SUCCESS,
status,
"Ioctl should succeed, actual status: {0}",
GetStatus(status));
VerifyTunnelOperationHeader(header.Value, RSVD_TUNNEL_OPERATION_CODE.RSVD_TUNNEL_META_OPERATION_START, (uint)RsvdStatus.STATUS_SVHDX_SUCCESS, RequestIdentifier);
DeleteSnapshot(snapshotId);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "3. Client closes the file.");
client.CloseSharedVirtualDisk();
}
public void BVT_Convert_VHDFile_to_VHDSetFile()
{
BaseTestSite.Log.Add(LogEntryKind.TestStep, "1. Client opens a shared virtual disk file and expects success.");
OpenSharedVHD(TestConfig.NameOfSharedVHDX, RSVD_PROTOCOL_VERSION.RSVD_PROTOCOL_VERSION_2);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "2. Client sends the tunnel operation SVHDX_META_OPERATION_START_REQUEST to convert a VHD file into a VHDSet file and expects success.");
SVHDX_META_OPERATION_START_REQUEST startRequest = new SVHDX_META_OPERATION_START_REQUEST();
startRequest.TransactionId = System.Guid.NewGuid();
startRequest.OperationType = Operation_Type.SvhdxMetaOperationTypeConvertToVHDSet;
SVHDX_META_OPERATION_CONVERT_TO_VHDSET convert = new SVHDX_META_OPERATION_CONVERT_TO_VHDSET();
convert.DestinationVhdSetName = TestConfig.NameOfConvertedSharedVHDS;
convert.DestinationVhdSetNameLength = (uint)(convert.DestinationVhdSetName.Length + 1) * 2;
byte[] payload = client.CreateTunnelMetaOperationStartConvertToVHDSetRequest(
startRequest,
convert);
SVHDX_TUNNEL_OPERATION_HEADER? header;
SVHDX_TUNNEL_OPERATION_HEADER? response;
//For RSVD_TUNNEL_META_OPERATION_START operation code, the IOCTL code should be FSCTL_SVHDX_ASYNC_TUNNEL_REQUEST
uint status = client.TunnelOperation<SVHDX_TUNNEL_OPERATION_HEADER>(
true,//true for Async operation, false for non-async operation
RSVD_TUNNEL_OPERATION_CODE.RSVD_TUNNEL_META_OPERATION_START,
++RequestIdentifier,
payload,
out header,
out response);
BaseTestSite.Assert.AreEqual(
(uint)Smb2Status.STATUS_SUCCESS,
status,
"Ioctl should succeed, actual status: {0}",
GetStatus(status));
VerifyTunnelOperationHeader(header.Value, RSVD_TUNNEL_OPERATION_CODE.RSVD_TUNNEL_META_OPERATION_START, (uint)RsvdStatus.STATUS_SVHDX_SUCCESS, RequestIdentifier);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "3. Client closes the file.");
client.CloseSharedVirtualDisk();
BaseTestSite.Log.Add(LogEntryKind.TestStep, "4. Client queris the converted disk info and expects the format is changed successfully.");
CheckDiskFormat();
}
public void BVT_Create_Delete_Checkpoint()
{
ulong requestId = 0;
BaseTestSite.Log.Add(LogEntryKind.TestStep, "1. Client opens a shared virtual disk file and expects success.");
OpenSharedVHD(TestConfig.NameOfSharedVHDS, requestId++);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "2. Client sends the first tunnel operation SVHDX_META_OPERATION_START_REQUEST to create a snapshot, with Stage1 set to Initialize and expects success.");
SVHDX_META_OPERATION_START_REQUEST startRequest = new SVHDX_META_OPERATION_START_REQUEST();
startRequest.TransactionId = System.Guid.NewGuid();
startRequest.OperationType = Operation_Type.SvhdxMetaOperationTypeCreateSnapshot;
startRequest.Padding = new byte[4];
SVHDX_META_OPERATION_CREATE_SNAPSHOT createsnapshot = new SVHDX_META_OPERATION_CREATE_SNAPSHOT();
createsnapshot.SnapshotType = Snapshot_Type.SvhdxSnapshotTypeVM;
createsnapshot.Flags = Snapshot_Flags.SVHDX_SNAPSHOT_DISK_FLAG_ENABLE_CHANGE_TRACKING;
createsnapshot.Stage1 = Stage_Values.SvhdxSnapshotStageInitialize;
createsnapshot.Stage2 = Stage_Values.SvhdxSnapshotStageInvalid;
createsnapshot.Stage3 = Stage_Values.SvhdxSnapshotStageInvalid;
createsnapshot.Stage4 = Stage_Values.SvhdxSnapshotStageInvalid;
createsnapshot.Stage5 = Stage_Values.SvhdxSnapshotStageInvalid;
createsnapshot.Stage6 = Stage_Values.SvhdxSnapshotStageInvalid;
createsnapshot.SnapshotId = System.Guid.NewGuid();
createsnapshot.ParametersPayloadSize = (uint)0x00000000;
createsnapshot.Padding = new byte[24];
byte[] payload = client.CreateTunnelMetaOperationStartCreateSnapshotRequest(
startRequest,
createsnapshot);
SVHDX_TUNNEL_OPERATION_HEADER? header;
SVHDX_TUNNEL_OPERATION_HEADER? response;
//For RSVD_TUNNEL_META_OPERATION_START operation code, the IOCTL code should be FSCTL_SVHDX_ASYNC_TUNNEL_REQUEST
uint status = client.TunnelOperation<SVHDX_TUNNEL_OPERATION_HEADER>(
true,//true for Async operation, false for non-async operation
RSVD_TUNNEL_OPERATION_CODE.RSVD_TUNNEL_META_OPERATION_START,
requestId,
payload,
out header,
out response);
BaseTestSite.Assert.AreEqual(
(uint)Smb2Status.STATUS_SUCCESS,
status,
"Ioctl should succeed, actual status: {0}",
GetStatus(status));
VerifyTunnelOperationHeader(header.Value, RSVD_TUNNEL_OPERATION_CODE.RSVD_TUNNEL_META_OPERATION_START, (uint)RsvdStatus.STATUS_SVHDX_SUCCESS, requestId++);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "3. Client sends the second tunnel operation SVHDX_META_OPERATION_START_REQUEST to create a snapshot and expects success.");
createsnapshot.Flags = Snapshot_Flags.SVHDX_SNAPSHOT_FLAG_ZERO;
createsnapshot.Stage1 = Stage_Values.SvhdxSnapshotStageBlockIO;
createsnapshot.Stage2 = Stage_Values.SvhdxSnapshotStageSwitchObjectStore;
createsnapshot.Stage3 = Stage_Values.SvhdxSnapshotStageUnblockIO;
createsnapshot.Stage4 = Stage_Values.SvhdxSnapshotStageFinalize;
createsnapshot.Stage5 = Stage_Values.SvhdxSnapshotStageInvalid;
createsnapshot.Stage6 = Stage_Values.SvhdxSnapshotStageInvalid;
payload = client.CreateTunnelMetaOperationStartCreateSnapshotRequest(
startRequest,
createsnapshot);
//For RSVD_TUNNEL_META_OPERATION_START operation code, the IOCTL code should be FSCTL_SVHDX_ASYNC_TUNNEL_REQUEST
status = client.TunnelOperation<SVHDX_TUNNEL_OPERATION_HEADER>(
true,//true for Async operation, false for non-async operation
RSVD_TUNNEL_OPERATION_CODE.RSVD_TUNNEL_META_OPERATION_START,
requestId,
payload,
out header,
out response);
BaseTestSite.Assert.AreEqual(
(uint)Smb2Status.STATUS_SUCCESS,
status,
"Ioctl should succeed, actual status: {0}",
GetStatus(status));
VerifyTunnelOperationHeader(header.Value, RSVD_TUNNEL_OPERATION_CODE.RSVD_TUNNEL_META_OPERATION_START, (uint)RsvdStatus.STATUS_SVHDX_SUCCESS, requestId++);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "4. Verify the snapshot has been created after the operation.");
DoUntilSucceed(
() => CheckSnapshotExisted(ref requestId, client, createsnapshot.SnapshotId),
TestConfig.Timeout,
"Retry getting the snapshot to make sure it has been created until succeed within timeout span");
BaseTestSite.Log.Add(LogEntryKind.TestStep, "5. Client sends the operation SVHDX_TUNNEL_DELETE_SNAPSHOT_REQUEST to delete a snapshot and expects success.");
SVHDX_TUNNEL_DELETE_SNAPSHOT_REQUEST deleteRequest = new SVHDX_TUNNEL_DELETE_SNAPSHOT_REQUEST();
deleteRequest.SnapshotId = createsnapshot.SnapshotId;
deleteRequest.PersistReference = PersistReference_Flags.PersistReferenceFalse;
deleteRequest.SnapshotType = Snapshot_Type.SvhdxSnapshotTypeVM;
payload = client.CreateTunnelMetaOperationDeleteSnapshotRequest(
deleteRequest);
SVHDX_TUNNEL_OPERATION_HEADER? deleteResponse;
status = client.TunnelOperation<SVHDX_TUNNEL_OPERATION_HEADER>(
false,//true for Async operation, false for non-async operation
RSVD_TUNNEL_OPERATION_CODE.RSVD_TUNNEL_DELETE_SNAPSHOT,
requestId,
payload,
out header,
out deleteResponse);
BaseTestSite.Assert.AreEqual(
(uint)Smb2Status.STATUS_SUCCESS,
status,
"Ioctl should succeed, actual status: {0}",
GetStatus(status));
VerifyTunnelOperationHeader(header.Value, RSVD_TUNNEL_OPERATION_CODE.RSVD_TUNNEL_DELETE_SNAPSHOT, (uint)RsvdStatus.STATUS_SVHDX_SUCCESS, requestId++);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "6. Client closes the file.");
client.CloseSharedVirtualDisk();
}
public void BVT_ApplySnapshot()
{
BaseTestSite.Log.Add(LogEntryKind.TestStep, "1. Client opens a shared virtual disk file and expects success.");
OpenSharedVHD(TestConfig.NameOfSharedVHDS, RSVD_PROTOCOL_VERSION.RSVD_PROTOCOL_VERSION_2);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "2. Client reads 512 bytes and saves it for later comparation.");
byte[] byteBeforeChanged = null;
uint status = client.Read(0, 512, out byteBeforeChanged);
BaseTestSite.Assert.AreEqual(
(uint)0,
status,
"Read Status should be {0}, actual is {1}", GetStatus(0), GetStatus(status));
Guid snapshotId = Guid.NewGuid();
BaseTestSite.Log.Add(LogEntryKind.TestStep, "3. Client creates a snapshot.");
CreateSnapshot(snapshotId);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "4. Client closes the file.");
client.CloseSharedVirtualDisk();
BaseTestSite.Log.Add(LogEntryKind.TestStep, "5. Client reopens the shared virtual disk file and expects success.");
RequestIdentifier = 0;
OpenSharedVHD(TestConfig.NameOfSharedVHDS, RSVD_PROTOCOL_VERSION.RSVD_PROTOCOL_VERSION_2);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "6. Client sends Write request to change the file and expects success.");
byte[] payload = Smb2Utility.CreateRandomByteArray(512);
status = client.Write(0, payload);
BaseTestSite.Assert.AreEqual(
(uint)0,
status,
"Write Status should be {0}, actual is {1}", GetStatus(0), GetStatus(status));
BaseTestSite.Log.Add(LogEntryKind.TestStep, "7. Client sends Apply Snapshot request to apply the previous snapshot.");
SVHDX_APPLY_SNAPSHOT_PARAMS applySnapshot = new SVHDX_APPLY_SNAPSHOT_PARAMS();
applySnapshot.SnapshotID = snapshotId;
applySnapshot.SnapshotType = Snapshot_Type.SvhdxSnapshotTypeVM;
SVHDX_META_OPERATION_START_REQUEST startRequest = new SVHDX_META_OPERATION_START_REQUEST();
startRequest.TransactionId = Guid.NewGuid();
startRequest.OperationType = Operation_Type.SvhdxMetaOperationTypeApplySnapshot;
payload = client.CreateTunnelMetaOperationStartApplySnapshotRequest(startRequest, applySnapshot);
SVHDX_TUNNEL_OPERATION_HEADER? header;
SVHDX_TUNNEL_OPERATION_HEADER? response;
status = client.TunnelOperation<SVHDX_TUNNEL_OPERATION_HEADER>(
true,//true for Async operation, false for non-async operation
RSVD_TUNNEL_OPERATION_CODE.RSVD_TUNNEL_META_OPERATION_START,
++RequestIdentifier,
payload,
out header,
out response);
BaseTestSite.Assert.AreEqual(
(uint)Smb2Status.STATUS_SUCCESS,
status,
"Ioctl should succeed, actual status: {0}",
GetStatus(status));
VerifyTunnelOperationHeader(header.Value, RSVD_TUNNEL_OPERATION_CODE.RSVD_TUNNEL_META_OPERATION_START, (uint)RsvdStatus.STATUS_SVHDX_SUCCESS, RequestIdentifier);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "8. Client rereads 512 bytes and compares it with the previously saved bytes.");
byte[] byteAfterApplied = null;
status = client.Read(0, 512, out byteAfterApplied);
BaseTestSite.Assert.AreEqual(
(uint)0,
status,
"Read Status should be {0}, actual is {1}", GetStatus(0), GetStatus(status));
bool equal = ArrayUtility.CompareArrays(byteBeforeChanged, byteAfterApplied);
BaseTestSite.Assert.AreEqual(
true,
equal,
"The bytes after snapshot applied should be the same with the original.");
BaseTestSite.Log.Add(LogEntryKind.TestStep, "9. Client deletes the snapshot.");
DeleteSnapshot(snapshotId);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "10. Client closes the file.");
client.CloseSharedVirtualDisk();
}
public void BVT_Optimize()
{
BaseTestSite.Log.Add(LogEntryKind.TestStep, "1. Client opens a shared virtual disk file and expects success.");
OpenSharedVHD(TestConfig.NameOfSharedVHDS, RSVD_PROTOCOL_VERSION.RSVD_PROTOCOL_VERSION_2);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "2. Client sends the tunnel operation SVHDX_META_OPERATION_START_REQUEST with an Optimize request.");
SVHDX_META_OPERATION_START_REQUEST startRequest = new SVHDX_META_OPERATION_START_REQUEST();
startRequest.TransactionId = System.Guid.NewGuid();
startRequest.OperationType = Operation_Type.SvhdxMetaOperationTypeOptimize;
byte[] payload = client.CreateTunnelMetaOperationStartOptimizeRequest(
startRequest);
SVHDX_TUNNEL_OPERATION_HEADER? header;
SVHDX_TUNNEL_OPERATION_HEADER? response;
//For RSVD_TUNNEL_META_OPERATION_START operation code, the IOCTL code should be FSCTL_SVHDX_ASYNC_TUNNEL_REQUEST
uint status = client.TunnelOperation<SVHDX_TUNNEL_OPERATION_HEADER>(
true,//true for Async operation, false for non-async operation
RSVD_TUNNEL_OPERATION_CODE.RSVD_TUNNEL_META_OPERATION_START,
++RequestIdentifier,
payload,
out header,
out response);
BaseTestSite.Assert.AreEqual(
(uint)Smb2Status.STATUS_SUCCESS,
status,
"Ioctl should succeed, actual status: {0}",
GetStatus(status));
VerifyTunnelOperationHeader(header.Value, RSVD_TUNNEL_OPERATION_CODE.RSVD_TUNNEL_META_OPERATION_START, (uint)RsvdStatus.STATUS_SVHDX_SUCCESS, RequestIdentifier);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "3. Client closes the file.");
client.CloseSharedVirtualDisk();
}