| public CreateViewStream ( ) : System.IO.MemoryMappedFiles.MemoryMappedViewStream | ||
| return | System.IO.MemoryMappedFiles.MemoryMappedViewStream | |
public Stream IncreaseSize(int value, out long offset)
{
lock (_lock)
{
while (Interlocked.Read(ref _counter) != 0)
{
if (!Monitor.Wait(_lock, 10000, true))
throw new NotSupportedException();
}
FileStream file = new FileStream(_filePath, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite);
try
{
offset = MathEx.RoundUp(file.Length, 0x800);
file.SetLength(offset + value);
_mmf = MemoryMappedFile.CreateFromFile(file, null, 0, MemoryMappedFileAccess.ReadWrite, null, HandleInheritability.Inheritable, false);
}
catch
{
file.SafeDispose();
throw;
}
Interlocked.Increment(ref _counter);
DisposableStream result = new DisposableStream(_mmf.CreateViewStream(offset, value, MemoryMappedFileAccess.ReadWrite));
result.AfterDispose.Add(new DisposableAction(Free));
return result;
}
}
private void CreateFileStreams()
{
if (_file != null || _fileStream != null)
throw new InvalidOperationException();
_file = MemoryMappedFile.CreateFromFile(FileName);
_fileStream = _file.CreateViewStream();
}
public SharedRingBuffer(string name, int size)
{
_size = size;
_memory = MemoryMappedFile.CreateOrOpen(name, size + 1);
_memoryStream = _memory.CreateViewStream();
_writer = new BinaryWriter(_memoryStream);
_reader = new BinaryReader(_memoryStream);
_writer.Write(char.MinValue);
}
public MappedFileBuffer(byte[] data)
{
_file = MemoryMappedFile.CreateNew(Guid.NewGuid().ToString(), data.Length);
_stream = _file.CreateViewStream();
_stream.Write(data, 0, data.Length);
//File.WriteAllBytes(_file.Name, data);
_size = (uint)data.Length;
}
public HeurFacade(string mutName, string mmfName, int RegIterations)
{
// Time of listening before register
this.Luogo1 = new Dictionary<string, Network>();
this.threshold = RegIterations;
this.mut = Mutex.OpenExisting(mutName); ;
this.mmf = MemoryMappedFile.OpenExisting(mmfName, MemoryMappedFileRights.FullControl, HandleInheritability.None);
this.stream = mmf.CreateViewStream(0, MappedFileDimension, MemoryMappedFileAccess.Read);
}
public MemoryMappedFileMessageSender(string name)
{
_file = MemoryMappedFile.CreateOrOpen(name, SizeOfFile);
_bytesWrittenAccessor = _file.CreateViewAccessor(0, SizeOfInt32);
_messageCompletedAccessor = _file.CreateViewAccessor(SizeOfInt32, SizeOfBool);
_stream = _file.CreateViewStream(SizeOfInt32 + SizeOfBool + SizeOfBool, SizeOfStream);
_messageSendingEvent = new EventWaitHandle(false, EventResetMode.AutoReset, name + "_MessageSending");
_messageReadEvent = new EventWaitHandle(false, EventResetMode.AutoReset, name + "_MessageRead");
_messageCancelledEvent = new EventWaitHandle(false, EventResetMode.ManualReset, name + "_MessageCancelled");
_bytesWrittenEvent = new EventWaitHandle(false, EventResetMode.AutoReset, name + "_BytesWritten");
_bytesReadEvent = new EventWaitHandle(false, EventResetMode.AutoReset, name + "_BytesRead");
}
/// <summary>
/// 非持久化内存映射文件写入
/// </summary>
/// <param name="name"></param>
/// <param name="capacity"></param>
/// <param name="en"></param>
/// <param name="buffer"></param>
public void Write(string name, Int64 capacity, Encoding en, byte[] buffer)
{
using (mmf = MemoryMappedFile.CreateNew(name, capacity, MemoryMappedFileAccess.ReadWrite))
{
using (MemoryMappedViewStream mmvs = mmf.CreateViewStream())
{
using (BinaryWriter bw = new BinaryWriter(mmvs, en))
{
bw.Write(buffer);
}
}
}
}
/// <summary>
/// Creates a new FileReader instance.
/// </summary>
/// <param name="Path">The path of the file to read.</param>
/// <param name="BigEndian">Is the filed stored as big endian?</param>
public FileReader(string Path, bool BigEndian)
{
m_MemFile = MemoryMappedFile.CreateFromFile(Path, FileMode.Open, Guid.NewGuid().ToString(), 0,
MemoryMappedFileAccess.Read);
try
{
m_Reader = new BinaryReader(m_MemFile.CreateViewStream(0, 0, MemoryMappedFileAccess.Read));
}
catch(IOException Exception)
{
throw new ReadingException("Couldn't open file - FileReader.cs\r\n" + Exception.ToString());
}
}
/// <summary>
/// 内存映射文件读取
/// </summary>
/// <param name="name">内存映射文件名称</param>
/// <param name="capacity">内存映射文件大小</param>
/// <param name="en">编码</param>
public byte[] Read(string name, Int64 capacity, Encoding en)
{
byte[] buffer = new byte[capacity];
using (mmf = MemoryMappedFile.OpenExisting(name))
{
using (MemoryMappedViewStream mmvs = mmf.CreateViewStream())
{
using (BinaryReader br = new BinaryReader(mmvs, en))
{
int length = int.Parse(capacity.ToString());
br.Read(buffer, 0, length);
}
}
}
return buffer;
}
public FileSegment(MemoryMappedFile mmf, long offset, long length, MemoryMappedFileAccess access)
{
_mmf = Exceptions.CheckArgumentNull(mmf, "mmf");
try
{
_length = length;
if (_length == 0)
_stream = new MemoryStream();
else
_stream = mmf.CreateViewStream(offset, length, access);
}
catch
{
_mmf.Dispose();
throw;
}
}
public ConnectImpl()
{
_onDataUpdatedEvent = new EventWaitHandle(true, EventResetMode.ManualReset, OnDataUpdatedEventName);
_onWriteLockMutex = new Mutex(false, OnWriteLockMutexName);
using (GetLock())
{
try
{
_memoryMappedFile = MemoryMappedFile.OpenExisting(MemoryMappedFileName);
}
catch (FileNotFoundException)
{
_memoryMappedFile = MemoryMappedFile.CreateNew(MemoryMappedFileName, MemoryMappedFileSize);
}
_memoryMappedViewAccessor = _memoryMappedFile.CreateViewAccessor();
_memoryMappedViewStream = _memoryMappedFile.CreateViewStream();
_memoryMappedViewHandle = _memoryMappedViewStream.SafeMemoryMappedViewHandle.DangerousGetHandle();
}
}
public ParityChange(Parity parity, Config config, UInt32 startBlock, UInt32 lengthInBlocks)
{
this.parity = parity;
this.startBlock = startBlock;
tempDir = config.TempDir;
writingToMMF = true;
UInt32 maxMMFBlocks = Parity.LengthInBlocks((long)config.MaxTempRAM * 1024 * 1024);
UInt32 mmfBlocks = (lengthInBlocks < maxMMFBlocks) ? lengthInBlocks : maxMMFBlocks;
try {
mmf = MemoryMappedFile.CreateNew("disparity.tmp", (long)mmfBlocks * Parity.BLOCK_SIZE);
mmfStream = mmf.CreateViewStream();
}
catch (Exception e) {
LogFile.Log("Could not create memory mapped file: " + e.Message);
// We'll use a temp file only
mmf = null;
mmfStream = null;
writingToMMF = false;
}
tempFileStream = null;
parityBlock = new ParityBlock(parity);
block = startBlock;
}
public DumpFileMemoryReader(string dumpFilePath)
{
bool dispose = true;
FileStream fileStream = null;
MemoryMappedFile memoryMappedFile = null;
MemoryMappedViewStream stream = null;
try
{
fileStream = new FileStream(dumpFilePath, FileMode.Open, FileAccess.Read);
memoryMappedFile = MemoryMappedFile.CreateFromFile(fileStream, Guid.NewGuid().ToString(), fileStream.Length, MemoryMappedFileAccess.Read, new MemoryMappedFileSecurity(), HandleInheritability.Inheritable, false);
stream = memoryMappedFile.CreateViewStream(0, fileStream.Length, MemoryMappedFileAccess.Read);
stream.SafeMemoryMappedViewHandle.AcquirePointer(ref basePointer);
IntPtr streamPointer = IntPtr.Zero;
uint streamSize = 0;
MINIDUMP_DIRECTORY directory = new MINIDUMP_DIRECTORY();
if (!MiniDumpReadDumpStream((IntPtr)basePointer, MINIDUMP_STREAM_TYPE.Memory64ListStream, ref directory, ref streamPointer, ref streamSize))
throw new Exception("Unable to read mini dump stream");
var data = (MINIDUMP_MEMORY64_LIST)Marshal.PtrToStructure(streamPointer, typeof(MINIDUMP_MEMORY64_LIST));
ulong lastEnd = data.BaseRva;
ranges = new MemoryLocation[data.NumberOfMemoryRanges];
for (int i = 0; i < ranges.Length; i++)
{
var descriptor = (MINIDUMP_MEMORY_DESCRIPTOR64)Marshal.PtrToStructure(streamPointer + sizeof(MINIDUMP_MEMORY64_LIST) + i * sizeof(MINIDUMP_MEMORY_DESCRIPTOR64), typeof(MINIDUMP_MEMORY_DESCRIPTOR64));
ranges[i] = new MemoryLocation()
{
MemoryStart = descriptor.StartOfMemoryRange,
MemoryEnd = descriptor.StartOfMemoryRange + descriptor.DataSize,
FilePosition = lastEnd,
};
lastEnd += descriptor.DataSize;
}
int newEnd = 0;
for (int i = 1; i < ranges.Length; i++)
if (ranges[i].MemoryStart == ranges[newEnd].MemoryEnd)
ranges[newEnd].MemoryEnd = ranges[i].MemoryEnd;
else
ranges[++newEnd] = ranges[i];
newEnd++;
Array.Resize(ref ranges, newEnd);
finder = new MemoryRegionFinder(ranges.Select(r => new MemoryRegion { BaseAddress = r.MemoryStart, MemoryEnd = r.MemoryEnd }).ToArray());
dispose = false;
}
finally
{
if (dispose)
{
stream.SafeMemoryMappedViewHandle.ReleasePointer();
if (stream != null)
{
stream.Dispose();
}
if (memoryMappedFile != null)
{
memoryMappedFile.Dispose();
}
if (fileStream != null)
{
fileStream.Dispose();
}
}
else
{
this.fileStream = fileStream;
this.stream = stream;
this.memoryMappedFile = memoryMappedFile;
}
}
}
/// <summary>
/// The copy next chunk async.
/// </summary>
/// <param name="memoryMappedFile">
/// The memory mapped file.
/// </param>
/// <returns>
/// The <see cref="Task"/>.
/// </returns>
/// <exception cref="DownloadAcceleratorException">
/// Thrown if the web server returns the wrong amount of data.
/// </exception>
private async Task<Status> CopyNextChunkAsync(MemoryMappedFile memoryMappedFile)
{
HttpWebRequest httpWebRequest = this.GetWebRequest();
long chunkId;
lock (this.stateLock)
{
if (this.chunkPosition == this.numberOfChunks)
{
return Status.Complete;
}
chunkId = this.chunkPosition++;
}
long offset = chunkId * this.chunkSize;
long length = Math.Min(this.chunkSize, this.Size - offset);
httpWebRequest.AddRange(offset, offset + length - 1);
using (WebResponse webResponse = await httpWebRequest.GetResponseAsync())
{
if (long.Parse(webResponse.Headers[HttpResponseHeader.ContentLength]) != length)
{
throw new DownloadAcceleratorException("Server returned incorrect amount of data");
}
using (MemoryMappedViewStream memoryMappedViewStream = memoryMappedFile.CreateViewStream(offset, length))
{
await this.CopyToWithProgressAsync(webResponse.GetResponseStream(), memoryMappedViewStream);
}
}
return Status.Incomplete;
}
private void Init()
{
mmf = MemoryMappedFile.OpenExisting(SHARE_MEMORY_NAME);
mmfvs = mmf.CreateViewStream();
}
private void MainForm_Load(object sender, EventArgs e)
{
_map = MemoryMappedFile.CreateNew("SJackConfig", 4096, MemoryMappedFileAccess.ReadWrite);
using (Stream stm = _map.CreateViewStream())
{
using (BinaryWriter writer = new BinaryWriter(stm))
{
}
}
UpdateMap();
RefreshProcessList();
}
/// <summary>
///
/// Read buffer from file and return it as a string
/// </summary>
/// <param name="mmf"></param>
/// <param name="offset"></param>
/// <param name="length"></param>
/// <returns></returns>
private string ReadFromFile(MemoryMappedFile mmf, long offset, long length)
{
using (var accessor = mmf.CreateViewStream(offset, length))
{
//TODO: There must be a better way to return the buffer.
byte[] buffer = new byte[length + 1];
int a = accessor.Read(buffer, 0, (int)length);
return Encoding.ASCII.GetString(buffer, 0, a);
}
}
static void GetRequest(string url, long fileSize, MemoryMappedFile mmap, int fragNo, int count)
{
Interlocked.Increment(ref running);
long length = fileSize / count;
long offset = length * fragNo;
Console.Out.WriteLine("Fragment {0} offset {1} size {2}", fragNo, offset, length);
Stream file = mmap.CreateViewStream(offset, length);
HttpWebRequest get = (HttpWebRequest)HttpWebRequest.Create(url);
get.AddRange(offset, offset + length-1);
get.BeginGetResponse((ar) =>
{
try
{
WebResponse resp = get.EndGetResponse(ar);
Stream web = resp.GetResponseStream();
byte[] buffer = new byte[4096];
int position = 0;
AsyncCallback cbBuffer = null;
cbBuffer = (bar) =>
{
try
{
int bytesRead = web.EndRead(bar);
Console.Out.WriteLine("Fragment {0} read {1}", fragNo, bytesRead);
if (0 < bytesRead)
{
// There are better ways to do this, eg. overlap reads and writes using 2 buffers
file.BeginWrite(buffer, 0, bytesRead, (war) =>
{
try
{
file.EndWrite(war);
position += bytesRead;
Console.Out.WriteLine("Fragment {0} write {1}", fragNo, bytesRead);
web.BeginRead(buffer, 0, buffer.Length, cbBuffer, null);
}
catch (Exception e)
{
Console.Error.WriteLine(e);
CompleteOne();
}
}, null);
}
else
{
web.Dispose();
file.Dispose();
Console.Out.WriteLine("Fragment {0} done", fragNo);
CompleteOne();
}
}
catch (Exception e)
{
Console.Error.WriteLine(e);
CompleteOne();
}
};
// start reading
web.BeginRead(buffer, 0, buffer.Length, cbBuffer, null);
}
catch (Exception e)
{
Console.Error.WriteLine(e);
CompleteOne();
}
}, null);
}
internal ManagedMemoryBlock(string @namespace, string key, int bufferSize, int bufferId)
{
Namespace = @namespace;
Key = key;
ProfilerHasResults = new EventWaitHandle(false, EventResetMode.ManualReset,
MakeName(@"\OpenCover_Profiler_Communication_SendResults_Event_", bufferId));
ResultsHaveBeenReceived = new EventWaitHandle(false, EventResetMode.ManualReset,
MakeName(@"\OpenCover_Profiler_Communication_ReceiveResults_Event_", bufferId));
_mmfResults = MemoryMappedFile.CreateNew(MakeName(@"\OpenCover_Profiler_Results_MemoryMapFile_", bufferId), bufferSize);
StreamAccessorResults = _mmfResults.CreateViewStream(0, bufferSize, MemoryMappedFileAccess.ReadWrite);
StreamAccessorResults.Write(BitConverter.GetBytes(0), 0, 4);
BufferSize = bufferSize;
}
/// <summary>
/// Load new stream from file starting at the given offset
/// </summary>
/// <param name="startOfStream"></param>
/// <param name="accessor"></param>
/// <param name="length"></param>
/// <param name="mmf"></param>
/// <param name="sizeOfFile"></param>
/// <param name="offsetInFile"></param>
private void LoadNewStream(ref long startOfStream, ref MemoryMappedViewStream accessor, int length, MemoryMappedFile mmf, long sizeOfFile, long offsetInFile)
{
long newStartOfStream = offsetInFile;
long endPoint = newStartOfStream + length + chunckSize;
long newLength = (endPoint > sizeOfFile) ? length : length + chunckSize;
newLength = (newLength > chunckSize) ? chunckSize : newLength; //Do not load streams more than chunck
accessor.Dispose();
accessor = mmf.CreateViewStream(newStartOfStream, newLength);
startOfStream = newStartOfStream;
}
internal ManagedCommunicationBlock(string @namespace, string key, int bufferSize, int bufferId)
{
Namespace = @namespace;
Key = key;
_memoryMappedFile = MemoryMappedFile.CreateNew(
MakeName(@"\OpenCover_Profiler_Communication_MemoryMapFile_", bufferId), bufferSize);
StreamAccessorComms = _memoryMappedFile.CreateViewStream(0, bufferSize, MemoryMappedFileAccess.ReadWrite);
ProfilerRequestsInformation = new EventWaitHandle(false, EventResetMode.ManualReset,
MakeName(@"\OpenCover_Profiler_Communication_SendData_Event_", bufferId));
InformationReadyForProfiler = new EventWaitHandle(false, EventResetMode.ManualReset,
MakeName(@"\OpenCover_Profiler_Communication_ReceiveData_Event_", bufferId));
InformationReadByProfiler = new EventWaitHandle(false, EventResetMode.ManualReset,
MakeName(@"\OpenCover_Profiler_Communication_ChunkData_Event_", bufferId));
DataCommunication = new byte[bufferSize];
PinnedDataCommunication = GCHandle.Alloc(DataCommunication, GCHandleType.Pinned);
}
protected override void OnStart(string[] args)
{
base.OnStart(args);
client = new WlanClient();
//Miofile = "C:\\" + DateTime.Now.ToLongDateString() + "-" +DateTime.Now.ToShortTimeString() + "_catture.txt";
//System.IO.File.AppendAllText("c:\\catture.txt", "PARTOOOOOOOOOOOOOOOOOOOOO\r\n");
// Initialize data structure
aTimer = new System.Timers.Timer();
aTimer.Elapsed += new ElapsedEventHandler(OnTimedEvent);
aTimer.Interval = default_interval;
//System.IO.File.AppendAllText("c:\\catture.txt", "PARTOOOOOOOOOOOOOOOOOOOOO\r\n");
//initialize the mutex
mut = new Mutex(false,"Global\\ServiceMutex");
MutexSecurity mSec = mut.GetAccessControl();
var rule = new MutexAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null),
MutexRights.Modify
| MutexRights.Synchronize
| MutexRights.TakeOwnership
| MutexRights.ReadPermissions,
AccessControlType.Allow);
mSec.AddAccessRule(rule);
mut.SetAccessControl(mSec);
// Set the time interval
//System.IO.File.AppendAllText("c:\\catture.txt", "PARTOOOOOOOOOOOOOOOOOOOOO\r\n");
// File Mapping creation
try
{
mmf = MemoryMappedFile.CreateNew("Global\\Broadcast", MappedFileDimension, MemoryMappedFileAccess.ReadWrite);
}
catch (Exception e)
{
System.IO.File.AppendAllText("c:\\catture.txt", e.ToString());
}
var mmfSec = mmf.GetAccessControl();
mmfSec.SetAccessRule(new AccessRule<MemoryMappedFileRights>(new SecurityIdentifier(WellKnownSidType.WorldSid, null),MemoryMappedFileRights.FullControl | MemoryMappedFileRights.Read, AccessControlType.Allow));
mmf.SetAccessControl(mmfSec);
//System.IO.File.AppendAllText("c:\\catture.txt", "PARTOOOOOOOOOOOOOOOOOOOOO\r\n");
stream = mmf.CreateViewStream(0, MappedFileDimension, MemoryMappedFileAccess.ReadWrite);
//System.IO.File.AppendAllText("c:\\catture.txt", "FINISCO PARTENZA\r\n");
aTimer.Enabled = true;
}
void EnsureCapacity(long required)
{
long newLength = capacity;
while (newLength < required) {
newLength += 0x100000;
}
if (newLength != capacity) {
maData.Flush ();
maData.Dispose ();
mmfBlock.Dispose ();
string blockFileName = path.CreatePath ("block").Path;
FileStream fs = File.Open (blockFileName, FileMode.OpenOrCreate);
if ((capacity = fs.Length) == 0)
fs.SetLength (newLength);
fs.Close ();
mmfBlock = MemoryMappedFile.CreateFromFile (blockFileName, FileMode.Open);
maData = mmfBlock.CreateViewStream ();
}
}
/// <summary>
/// </summary>
/// <returns></returns>
public bool CreateServer()
{
try
{
_memoryMappedFile = MemoryMappedFile.CreateOrOpen(_smKeyStoreName, _smKeyStoreSize);
_reader = _memoryMappedFile.CreateViewAccessor(0, _smKeyStoreSize, MemoryMappedFileAccess.ReadWrite);
_writer = _memoryMappedFile.CreateViewStream(0, _smKeyStoreSize, MemoryMappedFileAccess.ReadWrite);
_keystoreLock = new Mutex(true, LageantLock, out _isLocked);
}
catch
{
return false;
}
return true;
}
private void read_events_thread() {
string prefix = use_global_ ? "Global\\" : "";
try {
memory_file_ = MemoryMappedFile.CreateNew(prefix + "DBWIN_BUFFER", 4096L);
bool created = false;
buffer_ready_ = new EventWaitHandle( false, EventResetMode.AutoReset, prefix + "DBWIN_BUFFER_READY", out created);
if (!created)
errors_.add("Can't create the DBWIN_BUFFER_READY event/" + use_global_);
if (created) {
data_ready_ = new EventWaitHandle(false, EventResetMode.AutoReset, prefix + "DBWIN_DATA_READY", out created);
if (!created)
errors_.add("Can't create the DBWIN_DATA_READY event/" + use_global_);
}
if (created) {
buffer_ready_.Set();
while (!disposed_) {
if (!data_ready_.WaitOne(1000))
continue;
using (var stream = memory_file_.CreateViewStream()) {
using (var reader = new BinaryReader(stream, Encoding.Default)) {
var process_id = (int)reader.ReadUInt32();
var raw = reader.ReadChars(4092);
var idx = Array.IndexOf(raw, '\0');
var msg = new string(raw, 0, idx);
find_process_id(process_id);
string process_name = pid_to_name_.ContainsKey(process_id) ? pid_to_name_[process_id] : "";
lock (this)
events_.Add(new debug_event {
unique_id = next_unique_id++, process_id = process_id, msg = msg, lo_process_name = process_name
});
}
}
buffer_ready_.Set();
}
}
} catch (Exception e) {
logger.Fatal("Can't read debug events " + e.Message);
errors_.add("Error reading debug events " + e.Message);
}
if ( memory_file_ != null)
memory_file_.Dispose();
if ( data_ready_ != null)
data_ready_.Dispose();
if ( buffer_ready_ != null)
buffer_ready_.Dispose();
}
internal ManagedMemoryBlock(string @namespace, string key, int bufferSize, int bufferId, IEnumerable<string> servicePrincpal)
{
Namespace = @namespace;
Key = key;
EventWaitHandleSecurity open = null;
MemoryMappedFileSecurity transparent = null;
var service = servicePrincpal.FirstOrDefault();
var currentIdentity = WindowsIdentity.GetCurrent();
if (service != null && currentIdentity != null)
{
open = new EventWaitHandleSecurity();
open.AddAccessRule(new EventWaitHandleAccessRule(currentIdentity.Name, EventWaitHandleRights.FullControl, AccessControlType.Allow));
// The event handles need more than just EventWaitHandleRights.Modify | EventWaitHandleRights.Synchronize to work
open.AddAccessRule(new EventWaitHandleAccessRule(service, EventWaitHandleRights.FullControl, AccessControlType.Allow));
transparent = new MemoryMappedFileSecurity();
transparent.AddAccessRule(new AccessRule<MemoryMappedFileRights>(currentIdentity.Name, MemoryMappedFileRights.FullControl, AccessControlType.Allow));
transparent.AddAccessRule(new AccessRule<MemoryMappedFileRights>(service, MemoryMappedFileRights.ReadWrite, AccessControlType.Allow));
}
bool createdNew;
ProfilerHasResults = new EventWaitHandle(
false,
EventResetMode.ManualReset,
MakeName(@"\OpenCover_Profiler_Communication_SendResults_Event_", bufferId),
out createdNew,
open);
ResultsHaveBeenReceived = new EventWaitHandle(
false,
EventResetMode.ManualReset,
MakeName(@"\OpenCover_Profiler_Communication_ReceiveResults_Event_", bufferId),
out createdNew,
open);
_mmfResults = MemoryMappedFile.CreateNew(
MakeName(@"\OpenCover_Profiler_Results_MemoryMapFile_", bufferId),
bufferSize,
MemoryMappedFileAccess.ReadWrite,
MemoryMappedFileOptions.None,
transparent,
HandleInheritability.Inheritable);
StreamAccessorResults = _mmfResults.CreateViewStream(0, bufferSize, MemoryMappedFileAccess.ReadWrite);
StreamAccessorResults.Write(BitConverter.GetBytes(0), 0, 4);
BufferSize = bufferSize;
}
internal ManagedCommunicationBlock(string @namespace, string key, int bufferSize, int bufferId, IEnumerable<string> servicePrincpal)
{
Namespace = @namespace;
Key = key;
EventWaitHandleSecurity open = null;
MemoryMappedFileSecurity transparent = null;
var service = servicePrincpal.FirstOrDefault();
var currentIdentity = WindowsIdentity.GetCurrent();
if (service != null && currentIdentity != null)
{
open = new EventWaitHandleSecurity();
open.AddAccessRule(new EventWaitHandleAccessRule(currentIdentity.Name, EventWaitHandleRights.FullControl, AccessControlType.Allow));
open.AddAccessRule(new EventWaitHandleAccessRule(service, EventWaitHandleRights.FullControl, AccessControlType.Allow));
transparent = new MemoryMappedFileSecurity();
transparent.AddAccessRule(new AccessRule<MemoryMappedFileRights>(currentIdentity.Name, MemoryMappedFileRights.FullControl, AccessControlType.Allow));
transparent.AddAccessRule(new AccessRule<MemoryMappedFileRights>(service, MemoryMappedFileRights.ReadWrite, AccessControlType.Allow));
}
_memoryMappedFile = MemoryMappedFile.CreateNew(
MakeName(@"\OpenCover_Profiler_Communication_MemoryMapFile_", bufferId),
bufferSize,
MemoryMappedFileAccess.ReadWrite,
MemoryMappedFileOptions.None,
transparent,
HandleInheritability.Inheritable);
StreamAccessorComms = _memoryMappedFile.CreateViewStream(0, bufferSize, MemoryMappedFileAccess.ReadWrite);
bool createdNew;
ProfilerRequestsInformation = new EventWaitHandle(
false,
EventResetMode.ManualReset,
MakeName(@"\OpenCover_Profiler_Communication_SendData_Event_", bufferId),
out createdNew,
open);
InformationReadyForProfiler = new EventWaitHandle(
false,
EventResetMode.ManualReset,
MakeName(@"\OpenCover_Profiler_Communication_ReceiveData_Event_", bufferId),
out createdNew,
open);
InformationReadByProfiler = new EventWaitHandle(
false,
EventResetMode.ManualReset,
MakeName(@"\OpenCover_Profiler_Communication_ChunkData_Event_", bufferId),
out createdNew,
open);
DataCommunication = new byte[bufferSize];
PinnedDataCommunication = GCHandle.Alloc(DataCommunication, GCHandleType.Pinned);
}
void Initialize()
{
if (!Directory.Exists (path.Path))
Directory.CreateDirectory (path.Path);
string blockFileName = path.CreatePath (name).Path;
Console.WriteLine ("Name: {0}", name);
Console.WriteLine ("Block: {0}", blockFileName);
bool blockExists = File.Exists (blockFileName);
if (!blockExists) {
FileStream fs;
fs = File.Open (blockFileName, FileMode.OpenOrCreate);
if ((capacity = fs.Length) == 0) {
fs.SetLength (capacity = 0x100000);
fs.WriteByte (0);
fs.WriteByte (0);
fs.WriteByte (1);//65536
fs.WriteByte (0);
fs.WriteByte (0);
fs.WriteByte (0);
fs.WriteByte (0);
fs.WriteByte (0);
}
fs.Close ();
}
mmfBlock = MemoryMappedFile.CreateFromFile (blockFileName, FileMode.Open);
maData = mmfBlock.CreateViewStream ();
offset = (long)
(((ulong)maData.ReadByte ()) |
((ulong)maData.ReadByte ()) << 8 |
((ulong)maData.ReadByte ()) << 16 |
((ulong)maData.ReadByte ()) << 24 |
((ulong)maData.ReadByte ()) << 32 |
((ulong)maData.ReadByte ()) << 40 |
((ulong)maData.ReadByte ()) << 48 |
((ulong)maData.ReadByte ()) << 56);
}
public SharedMemory(string name, IntPtr size)
{
mmf = MemoryMappedFile.OpenExisting(name + "_CONNECT_DATA");
mmva = mmf.CreateViewAccessor();
if (mmf.SafeMemoryMappedFileHandle.IsInvalid)
throw new MySqlException("Cannot open file mapping " + name);
mmvs = mmf.CreateViewStream(0L, size.ToInt64());
mmva = mmf.CreateViewAccessor(0L, size.ToInt64());
}