private static void WriteReportedProcesses(BuildXLWriter writer, Dictionary <ReportedProcess, int> processMap)
{
writer.WriteCompact(processMap.Count);
ReportedProcess[] processes = new ReportedProcess[processMap.Count];
foreach (var process in processMap)
{
processes[process.Value] = process.Key;
}
for (int i = 0; i < processes.Length; i++)
{
writer.Write(processes[i].ProcessId);
writer.Write(processes[i].Path);
writer.Write(processes[i].ProcessArgs);
writer.Write(processes[i].CreationTime);
writer.Write(processes[i].ExitTime);
writer.Write(processes[i].KernelTime);
writer.Write(processes[i].UserTime);
writer.Write(processes[i].IOCounters.ReadCounters.OperationCount);
writer.Write(processes[i].IOCounters.ReadCounters.TransferCount);
writer.Write(processes[i].IOCounters.WriteCounters.OperationCount);
writer.Write(processes[i].IOCounters.WriteCounters.TransferCount);
writer.Write(processes[i].IOCounters.OtherCounters.OperationCount);
writer.Write(processes[i].IOCounters.OtherCounters.TransferCount);
writer.Write(processes[i].ExitCode);
writer.Write(processes[i].ParentProcessId);
}
}
/// <nodoc />
public static Xldb.ReportedProcess ToReportedProcess(this ReportedProcess reportedProcess)
{
return(new Xldb.ReportedProcess()
{
Path = reportedProcess.Path,
ProcessId = reportedProcess.ProcessId,
ProcessArgs = reportedProcess.ProcessArgs,
ReadCounters = new Xldb.IOTypeCounters
{
OperationCount = reportedProcess.IOCounters.ReadCounters.OperationCount,
TransferCOunt = reportedProcess.IOCounters.ReadCounters.TransferCount
},
WriteCounters = new Xldb.IOTypeCounters
{
OperationCount = reportedProcess.IOCounters.WriteCounters.OperationCount,
TransferCOunt = reportedProcess.IOCounters.WriteCounters.TransferCount
},
OtherCounters = new Xldb.IOTypeCounters
{
OperationCount = reportedProcess.IOCounters.OtherCounters.OperationCount,
TransferCOunt = reportedProcess.IOCounters.OtherCounters.TransferCount
},
CreationTime = Google.Protobuf.WellKnownTypes.Timestamp.FromDateTime(reportedProcess.CreationTime),
ExitTime = Google.Protobuf.WellKnownTypes.Timestamp.FromDateTime(reportedProcess.ExitTime),
KernelTime = Google.Protobuf.WellKnownTypes.Duration.FromTimeSpan(reportedProcess.KernelTime),
UserTime = Google.Protobuf.WellKnownTypes.Duration.FromTimeSpan(reportedProcess.UserTime),
ExitCode = reportedProcess.ExitCode,
ParentProcessId = reportedProcess.ParentProcessId
});
}
private static ReportedProcess[] ReadReportedProcesses(BuildXLReader reader)
{
int count = reader.ReadInt32Compact();
ReportedProcess[] processes = new ReportedProcess[count];
for (int i = 0; i < count; i++)
{
processes[i] = new ReportedProcess(
reader.ReadUInt32(),
reader.ReadString(),
reader.ReadString());
processes[i].CreationTime = reader.ReadDateTime();
processes[i].ExitTime = reader.ReadDateTime();
processes[i].KernelTime = reader.ReadTimeSpan();
processes[i].UserTime = reader.ReadTimeSpan();
IOTypeCounters readCounters = new IOTypeCounters(reader.ReadUInt64(), reader.ReadUInt64());
IOTypeCounters writeCounters = new IOTypeCounters(reader.ReadUInt64(), reader.ReadUInt64());
IOTypeCounters otherCounters = new IOTypeCounters(reader.ReadUInt64(), reader.ReadUInt64());
processes[i].IOCounters = new IOCounters(readCounters, writeCounters, otherCounters);
processes[i].ExitCode = reader.ReadUInt32();
processes[i].ParentProcessId = reader.ReadUInt32();
}
return(processes);
}
private static ReportedProcess[] ReadReportedProcesses(BuildXLReader reader)
{
int count = reader.ReadInt32Compact();
ReportedProcess[] processes = new ReportedProcess[count];
for (int i = 0; i < count; i++)
{
processes[i] = ReportedProcess.Deserialize(reader);
}
return(processes);
}
public void DedupeReportedFileAccesses()
{
var process = new ReportedProcess(1000, "/usr/bin/touch");
var writeReport = new ReportedFileAccess(ReportedFileOperation.CreateFile,
process,
RequestedAccess.Write,
FileAccessStatus.Allowed,
true,
0,
Usn.Zero,
DesiredAccess.GENERIC_WRITE,
ShareMode.FILE_SHARE_WRITE,
CreationDisposition.CREATE_NEW,
FlagsAndAttributes.FILE_ATTRIBUTE_NORMAL,
AbsolutePath.Invalid,
"/tmp/out1",
"*");
var readReport = new ReportedFileAccess(ReportedFileOperation.GetFileAttributes,
process,
RequestedAccess.Read,
FileAccessStatus.Allowed,
true,
0,
Usn.Zero,
DesiredAccess.GENERIC_READ,
ShareMode.FILE_SHARE_READ,
CreationDisposition.OPEN_EXISTING,
FlagsAndAttributes.FILE_ATTRIBUTE_NORMAL,
AbsolutePath.Invalid,
"/tmp/out1",
"*");
HashSet <ReportedFileAccess> allFileAccesses = new HashSet <ReportedFileAccess>()
{
writeReport, readReport
};
HashSet <ReportedFileAccess> explicitFileAccesses = new HashSet <ReportedFileAccess>()
{
readReport, writeReport
};
var runner = CreateSandboxExecRunner();
var dedupedReports = runner.DedupeAccessReports(allFileAccesses, explicitFileAccesses);
XAssert.IsTrue(dedupedReports.Count == 2);
var result = new string[2];
dedupedReports.CopyTo(result);
XAssert.AreArraysEqual(new string[] { " W /tmp/out1", " R /tmp/out1" }, result, true);
}
private static void WriteReportedProcesses(BuildXLWriter writer, Dictionary <ReportedProcess, int> processMap)
{
writer.WriteCompact(processMap.Count);
ReportedProcess[] processes = new ReportedProcess[processMap.Count];
foreach (var process in processMap)
{
processes[process.Value] = process.Key;
}
for (int i = 0; i < processes.Length; i++)
{
processes[i].Serialize(writer);
}
}
private ReportedFileAccess CreateViolation(RequestedAccess access, AbsolutePath path)
{
var process = new ReportedProcess(1, ReportedExecutablePath);
return(ReportedFileAccess.Create(
ReportedFileOperation.CreateFile,
process,
access,
FileAccessStatus.Denied,
explicitlyReported: false,
error: 0,
usn: ReportedFileAccess.NoUsn,
desiredAccess: DesiredAccess.GENERIC_READ,
shareMode: ShareMode.FILE_SHARE_NONE,
creationDisposition: CreationDisposition.OPEN_ALWAYS,
flagsAndAttributes: FlagsAndAttributes.FILE_ATTRIBUTE_NORMAL,
path: path));
}
private XElement RenderReportedProcess(ReportedProcess data)
{
return(new XElement(
"div",
new XAttribute("class", "miniGroup"),
m_html.CreateRow("ProcessId", data.ProcessId.ToString(CultureInfo.InvariantCulture)),
m_html.CreateRow("ParentProcessId", data.ParentProcessId.ToString(CultureInfo.InvariantCulture)),
m_html.CreateRow("Path", data.Path),
m_html.CreateRow("ProcessArgs", data.ProcessArgs),
m_html.CreateRow("CreationTime", data.CreationTime),
m_html.CreateRow("ExitTime", data.ExitTime),
m_html.CreateRow("ExitCode", data.ExitCode.ToString(CultureInfo.InvariantCulture)),
m_html.CreateRow("KernelTime", data.KernelTime),
m_html.CreateRow("UserTime", data.UserTime),
m_html.CreateRow("IOCounters.Read", PrintIoTypeCounters(data.IOCounters.ReadCounters)),
m_html.CreateRow("IOCounters.Write", PrintIoTypeCounters(data.IOCounters.WriteCounters)),
m_html.CreateRow("IOCounters.Other", PrintIoTypeCounters(data.IOCounters.OtherCounters))));
}
private static ReportedProcessData CreateReportedProcessData(ReportedProcess data)
{
return(new ReportedProcessData
{
ProcessId = data.ProcessId,
ParentProcessId = data.ParentProcessId,
Path = data.Path,
ProcessArgs = data.ProcessArgs,
CreationTime = CreateString(data.CreationTime),
ExitTime = CreateString(data.ExitTime),
ExitCode = data.ExitCode,
KernelTime = CreateNumeric(data.KernelTime),
UserTime = CreateNumeric(data.UserTime),
IOCountersRead = CreateString(data.IOCounters.ReadCounters),
IOCountersWrite = CreateString(data.IOCounters.WriteCounters),
IOCountersOther = CreateString(data.IOCounters.OtherCounters)
});
}
protected ReportedFileAccess CreateRandomReportedFileAccess(ReportedProcess process = null)
{
Random r = new Random(123);
var manifestFile = CreateOutputFile();
return(new ReportedFileAccess(
RandomEnum <ReportedFileOperation>(r),
process ?? new ReportedProcess((uint)r.Next(), X("/x/processPath") + r.Next(), X("/x/processPath") + r.Next() + " args1 args2"),
RandomEnum <RequestedAccess>(r),
RandomEnum <FileAccessStatus>(r),
true,
(uint)r.Next(),
new Usn((ulong)r.Next()),
RandomEnum <DesiredAccess>(r),
RandomEnum <ShareMode>(r),
RandomEnum <CreationDisposition>(r),
RandomEnum <FlagsAndAttributes>(r),
manifestFile.Path,
X("/j/accessPath") + r.Next(),
null));
}
public void ReportedFileAccessEquality()
{
var pathTable = new PathTable();
AbsolutePath file1 = AbsolutePath.Create(pathTable, A("t", "file1.txt"));
AbsolutePath file2 = AbsolutePath.Create(pathTable, A("t", "file2.txt"));
var process = new ReportedProcess(0, string.Empty);
Test.BuildXL.TestUtilities.Xunit.StructTester.TestEquality(
baseValue:
ReportedFileAccess.Create(
ReportedFileOperation.CreateFile,
process,
RequestedAccess.Read,
FileAccessStatus.Allowed,
true,
0,
ReportedFileAccess.NoUsn,
DesiredAccess.GENERIC_READ,
ShareMode.FILE_SHARE_NONE,
CreationDisposition.OPEN_ALWAYS,
FlagsAndAttributes.FILE_ATTRIBUTE_NORMAL,
file1),
equalValue:
ReportedFileAccess.Create(
ReportedFileOperation.CreateFile,
process,
RequestedAccess.Read,
FileAccessStatus.Allowed,
true,
0,
ReportedFileAccess.NoUsn,
DesiredAccess.GENERIC_READ,
ShareMode.FILE_SHARE_NONE,
CreationDisposition.OPEN_ALWAYS,
FlagsAndAttributes.FILE_ATTRIBUTE_NORMAL,
file1),
notEqualValues: new[]
{
ReportedFileAccess.Create(
ReportedFileOperation.CreateFile,
process,
RequestedAccess.Read,
FileAccessStatus.Denied,
true,
0,
ReportedFileAccess.NoUsn,
DesiredAccess.GENERIC_READ,
ShareMode.FILE_SHARE_NONE,
CreationDisposition.OPEN_ALWAYS,
FlagsAndAttributes.FILE_ATTRIBUTE_NORMAL,
file1),
ReportedFileAccess.Create(
ReportedFileOperation.CreateFile,
process,
RequestedAccess.Read,
FileAccessStatus.Allowed,
true,
0,
ReportedFileAccess.NoUsn,
DesiredAccess.GENERIC_READ,
ShareMode.FILE_SHARE_NONE,
CreationDisposition.OPEN_ALWAYS,
FlagsAndAttributes.FILE_ATTRIBUTE_NORMAL,
file2),
ReportedFileAccess.Create(
ReportedFileOperation.CreateFile,
process,
RequestedAccess.Read,
FileAccessStatus.Allowed,
true,
0,
ReportedFileAccess.NoUsn,
DesiredAccess.GENERIC_READ,
ShareMode.FILE_SHARE_NONE,
CreationDisposition.OPEN_ALWAYS,
FlagsAndAttributes.FILE_ATTRIBUTE_NORMAL,
pathTable,
A("u", "file3.txt")),
ReportedFileAccess.Create(
ReportedFileOperation.CreateFile,
process,
RequestedAccess.Read,
FileAccessStatus.Denied,
true,
0,
ReportedFileAccess.NoUsn,
DesiredAccess.GENERIC_READ,
ShareMode.FILE_SHARE_NONE,
CreationDisposition.OPEN_ALWAYS,
FlagsAndAttributes.FILE_ATTRIBUTE_NORMAL,
pathTable,
A("u", "file4.txt")),
ReportedFileAccess.Create(
ReportedFileOperation.CreateFile,
process,
RequestedAccess.Read,
FileAccessStatus.Allowed,
false,
0,
ReportedFileAccess.NoUsn,
DesiredAccess.GENERIC_READ,
ShareMode.FILE_SHARE_NONE,
CreationDisposition.OPEN_ALWAYS,
FlagsAndAttributes.FILE_ATTRIBUTE_NORMAL,
file1),
ReportedFileAccess.Create(
ReportedFileOperation.CreateFile,
process,
RequestedAccess.Write,
FileAccessStatus.Allowed,
true,
0,
ReportedFileAccess.NoUsn,
DesiredAccess.GENERIC_READ,
ShareMode.FILE_SHARE_NONE,
CreationDisposition.OPEN_ALWAYS,
FlagsAndAttributes.FILE_ATTRIBUTE_NORMAL,
file1)
},
eq: (left, right) => left == right,
neq: (left, right) => left != right,
skipHashCodeForNotEqualValues: true);
Test.BuildXL.TestUtilities.Xunit.StructTester.TestEquality(
baseValue:
ReportedFileAccess.Create(
ReportedFileOperation.CreateFile,
process,
RequestedAccess.Read,
FileAccessStatus.Allowed,
true,
0,
ReportedFileAccess.NoUsn,
DesiredAccess.GENERIC_READ,
ShareMode.FILE_SHARE_NONE,
CreationDisposition.OPEN_ALWAYS,
FlagsAndAttributes.FILE_ATTRIBUTE_NORMAL,
pathTable,
A("x", "file5.txt")),
equalValue:
ReportedFileAccess.Create(
ReportedFileOperation.CreateFile,
process,
RequestedAccess.Read,
FileAccessStatus.Allowed,
true,
0,
ReportedFileAccess.NoUsn,
DesiredAccess.GENERIC_READ,
ShareMode.FILE_SHARE_NONE,
CreationDisposition.OPEN_ALWAYS,
FlagsAndAttributes.FILE_ATTRIBUTE_NORMAL,
pathTable,
A("x", "file5.txt")),
notEqualValues: new[]
{
ReportedFileAccess.Create(
ReportedFileOperation.CreateFile,
process,
RequestedAccess.Read,
FileAccessStatus.Denied,
true,
0,
ReportedFileAccess.NoUsn,
DesiredAccess.GENERIC_READ,
ShareMode.FILE_SHARE_NONE,
CreationDisposition.OPEN_ALWAYS,
FlagsAndAttributes.FILE_ATTRIBUTE_NORMAL,
pathTable,
A("x", "file5.txt")),
ReportedFileAccess.Create(
ReportedFileOperation.CreateFile,
process,
RequestedAccess.Read,
FileAccessStatus.Allowed,
true,
0,
new Usn(0),
DesiredAccess.GENERIC_READ,
ShareMode.FILE_SHARE_NONE,
CreationDisposition.OPEN_ALWAYS,
FlagsAndAttributes.FILE_ATTRIBUTE_NORMAL,
pathTable,
A("x", "file5.txt")),
ReportedFileAccess.Create(
ReportedFileOperation.CreateFile,
process,
RequestedAccess.Read,
FileAccessStatus.Allowed,
true,
0,
ReportedFileAccess.NoUsn,
DesiredAccess.GENERIC_READ,
ShareMode.FILE_SHARE_NONE,
CreationDisposition.OPEN_ALWAYS,
FlagsAndAttributes.FILE_ATTRIBUTE_NORMAL,
file1),
ReportedFileAccess.Create(
ReportedFileOperation.CreateFile,
process,
RequestedAccess.Read,
FileAccessStatus.Denied,
true,
0,
ReportedFileAccess.NoUsn,
DesiredAccess.GENERIC_READ,
ShareMode.FILE_SHARE_NONE,
CreationDisposition.OPEN_ALWAYS,
FlagsAndAttributes.FILE_ATTRIBUTE_NORMAL,
file2),
ReportedFileAccess.Create(
ReportedFileOperation.CreateFile,
process,
RequestedAccess.Read,
FileAccessStatus.Allowed,
true,
0,
ReportedFileAccess.NoUsn,
DesiredAccess.GENERIC_READ,
ShareMode.FILE_SHARE_NONE,
CreationDisposition.OPEN_ALWAYS,
FlagsAndAttributes.FILE_ATTRIBUTE_NORMAL,
pathTable,
A("u", "file3.txt")),
ReportedFileAccess.Create(
ReportedFileOperation.CreateFile,
process,
RequestedAccess.Read,
FileAccessStatus.Allowed,
true,
0,
ReportedFileAccess.NoUsn,
DesiredAccess.GENERIC_READ,
ShareMode.FILE_SHARE_NONE,
CreationDisposition.OPEN_ALWAYS,
FlagsAndAttributes.FILE_ATTRIBUTE_NORMAL,
pathTable,
A("u", "file4.txt")),
ReportedFileAccess.Create(
ReportedFileOperation.CreateFile,
process,
RequestedAccess.Read,
FileAccessStatus.Allowed,
false,
0,
ReportedFileAccess.NoUsn,
DesiredAccess.GENERIC_READ,
ShareMode.FILE_SHARE_NONE,
CreationDisposition.OPEN_ALWAYS,
FlagsAndAttributes.FILE_ATTRIBUTE_NORMAL,
pathTable,
A("x", "file5.txt")),
ReportedFileAccess.Create(
ReportedFileOperation.CreateFile,
process,
RequestedAccess.Write,
FileAccessStatus.Allowed,
true,
0,
ReportedFileAccess.NoUsn,
DesiredAccess.GENERIC_READ,
ShareMode.FILE_SHARE_NONE,
CreationDisposition.OPEN_ALWAYS,
FlagsAndAttributes.FILE_ATTRIBUTE_NORMAL,
pathTable,
A("x", "file5.txt"))
},
eq: (left, right) => left == right,
neq: (left, right) => left != right,
skipHashCodeForNotEqualValues: true);
}
public void ReportedFileAccessCreate()
{
var pathTable = new PathTable();
AbsolutePath file1 = AbsolutePath.Create(pathTable, A("t", "file1.txt"));
var process = new ReportedProcess(0, string.Empty);
ReportedFileAccess rfa1 = ReportedFileAccess.Create(
ReportedFileOperation.CreateFile,
process,
RequestedAccess.Read,
FileAccessStatus.Allowed,
true,
0,
ReportedFileAccess.NoUsn,
DesiredAccess.GENERIC_READ,
ShareMode.FILE_SHARE_NONE,
CreationDisposition.OPEN_ALWAYS,
FlagsAndAttributes.FILE_ATTRIBUTE_NORMAL,
file1);
XAssert.AreEqual(rfa1.Status, FileAccessStatus.Allowed);
XAssert.AreEqual(rfa1.ManifestPath, file1);
XAssert.AreEqual(rfa1.Path, null);
XAssert.AreEqual(A("t", "file1.txt"), rfa1.GetPath(pathTable));
ReportedFileAccess rfa2 = ReportedFileAccess.Create(
ReportedFileOperation.CreateFile,
process,
RequestedAccess.Read,
FileAccessStatus.CannotDeterminePolicy,
true,
0,
new Usn(0),
DesiredAccess.GENERIC_READ,
ShareMode.FILE_SHARE_NONE,
CreationDisposition.OPEN_ALWAYS,
FlagsAndAttributes.FILE_ATTRIBUTE_NORMAL,
pathTable,
A("t", "file1.txt"));
XAssert.AreEqual(rfa2.Status, FileAccessStatus.CannotDeterminePolicy);
XAssert.AreEqual(rfa2.ManifestPath, file1);
XAssert.AreEqual(rfa2.Path, null);
XAssert.AreEqual(A("t", "file1.txt"), rfa2.GetPath(pathTable));
ReportedFileAccess rfa3 = ReportedFileAccess.Create(
ReportedFileOperation.CreateFile,
process,
RequestedAccess.Read,
FileAccessStatus.Denied,
true,
0,
ReportedFileAccess.NoUsn,
DesiredAccess.GENERIC_READ,
ShareMode.FILE_SHARE_NONE,
CreationDisposition.OPEN_ALWAYS,
FlagsAndAttributes.FILE_ATTRIBUTE_NORMAL,
pathTable,
A("t", "file2.txt"));
XAssert.AreEqual(rfa3.Status, FileAccessStatus.Denied);
XAssert.AreEqual(rfa3.ManifestPath, AbsolutePath.Invalid);
XAssert.AreEqual(rfa3.Path, A("t", "file2.txt"));
XAssert.AreEqual(A("t", "file2.txt"), rfa3.GetPath(pathTable));
}
/// <nodoc/>
public ProcessNode(ReportedProcess reportedProcess)
{
ReportedProcess = reportedProcess;
m_children = new List <ProcessNode>();
}
