public void Write(ByteBufferRef buf, int offset)
{
Contract.Assert(offset >= 0 && offset + Size <= buf.Length);
Deserializer.WriteInt(fd, buf, offset);
Deserializer.WriteShort(events, buf, offset + sizeof(int));
Deserializer.WriteShort(revents, buf, offset + sizeof(int) + sizeof(short));
}
public void Write(ByteBufferRef buf, int offset)
{
Contract.Assert(offset >= 0 && offset + Size <= buf.Length);
Deserializer.WriteInt(fd, buf, offset);
Deserializer.WriteShort(events, buf, offset + sizeof(int));
Deserializer.WriteShort(revents, buf, offset + sizeof(int) + sizeof(short));
}
public static unsafe void CalculateHMAC(int pg_offset, uint filesize, byte[] page_signatures, byte *result)
{
var b = CalculateHMAC(pg_offset, filesize, page_signatures);
var buf = new ByteBufferRef(new IntPtr(result), (int)SHA1Managed.SHA1HashSize);
buf.CopyFrom(0, b);
}
public static void DumpUserBuf(Thread current, UserPtr writeBuf, int size)
{
var buf = new byte[(size + 3) / 4];
var buf_ref = new ByteBufferRef(buf);
writeBuf.Read(current, buf, size);
DumpBuf(new Pointer(buf_ref.Location), size);
}
internal int Write(Thread current, ref Arch.ExceptionRegisters regs, ref ByteBufferRef buf, int len)
{
Contract.Requires(GhostOwner == current.Parent);
var ret = inode.Write(current, ref regs, ref buf, len, position, this);
return(ret);
}
private static int ReadUserBuffer(Thread current, ByteBufferRef src, int buf_offset, CachePage page, int page_offset, int len)
{
var dst = new ByteBufferRef(page.Buffer.Location + page_offset, len);
dst.CopyFrom(buf_offset, src);
return(0);
}
internal ThreadCompletionEntryWithBuffer(Thread current, Kind kind, ByteBufferRef buf)
: base(current, kind)
{
Contract.Ensures(this.buf.Length == buf.Length);
Contract.Ensures(this.buf.Location == buf.Location);
this.buf = buf;
}
internal int TranslateToUserFdlist(Thread current, ByteBufferRef buf, int poll_ret, int maxfds, UserPtr userPtr, short event_type)
{
Contract.Requires(poll_ret * pollfd.Size < buf.Length);
if (userPtr == UserPtr.Zero)
return 0;
var res = 0;
var len = (maxfds + 7) / 8;
var vec = new FixedSizeBitVector(maxfds);
for (int i = 0; i < poll_ret; i++)
{
var poll_struct = pollfd.Deserialize(buf, i * pollfd.Size);
var linux_fd = poll_struct.fd;
var node = Lookup(linux_fd);
if (node == null)
return -ErrorCode.EBADF;
if ((poll_struct.revents & event_type & node.event_type) != 0)
{
vec.Set(node.expressos_fd);
++res;
}
}
if (userPtr.Write(current, vec.Buffer) != 0)
return -ErrorCode.EFAULT;
return res;
}
internal void WriteString16(string s)
{
var r = new ByteBufferRef(Buffer);
if (cursor + sizeof(int) > Buffer.Length)
{
return;
}
WriteInt32(s.Length);
foreach (var c in s)
{
if (cursor + sizeof(short) > r.Length)
{
return;
}
Deserializer.WriteShort((short)c, r, cursor);
cursor += sizeof(short);
}
if (cursor + sizeof(short) > r.Length)
{
return;
}
Deserializer.WriteShort(0, r, cursor);
cursor += sizeof(short);
Pad();
}
public void CopyFrom(int offset, ByteBufferRef src)
{
Contract.Requires(offset >= 0 && offset < Length);
for (var i = 0; i < src.Length && i + offset < length; ++i)
{
Set(i + offset, src[i]);
}
}
private unsafe int Read(Thread current, void *dst, int length)
{
var process = current.Parent;
var buf = new ByteBufferRef(new IntPtr(dst), length);
var bytesRead = Read(process, buf, false);
return(length - bytesRead);
}
public static void WriteInt(int val, ByteBufferRef buf, int offset)
{
Contract.Requires(offset >= 0);
Contract.Requires(buf.Length >= offset + sizeof(int));
var v = (uint)val;
WriteUInt(v, buf, offset);
}
public short revents; /* returned events */
#endregion Fields
#region Methods
public static pollfd Deserialize(ByteBufferRef buf, int offset)
{
Contract.Assert(offset >= 0 && offset + Size <= buf.Length);
pollfd res;
res.fd = Deserializer.ReadInt(buf, offset);
res.events = Deserializer.ReadShort(buf, offset + sizeof(int));
res.revents = Deserializer.ReadShort(buf, offset + sizeof(int) + sizeof(short));
return res;
}
private int Write(Thread current, ByteBufferRef buf, int len, uint pos)
{
var writtenBytes = 0;
var remainedBytes = len;
var currentPageIndex = (int)Arch.ArchDefinition.PageIndex(pos);
CachePage page = null;
while (remainedBytes > 0)
{
page = Pages.Lookup(currentPageIndex / Arch.ArchDefinition.PageSize);
if (page == null)
{
page = CachePage.Allocate(current.Parent, currentPageIndex / Arch.ArchDefinition.PageSize);
int currentBlockId = currentPageIndex / Arch.ArchDefinition.PageSize;
if (currentBlockId < OnDiskBlock)
{
// Case (1)
var succeed = page.Load(this);
Contract.Assert(page.Next == null);
if (!succeed)
{
return(-ErrorCode.EIO);
}
}
else
{
// Case (2) / (3)
// assert cachedPage.Empty();
}
Pages.Add(page);
}
// Copying
int pageCursor = Arch.ArchDefinition.PageOffset((int)(pos + writtenBytes));
int chunkLen = Arch.ArchDefinition.PageSize - pageCursor < remainedBytes ? Arch.ArchDefinition.PageSize - pageCursor : remainedBytes;
var left = ReadUserBuffer(current, buf, writtenBytes, page, pageCursor, chunkLen);
writtenBytes += chunkLen - left;
if (left != 0)
{
return(-ErrorCode.EFAULT);
}
remainedBytes -= chunkLen;
// Update FileSize
if (pos + writtenBytes > FileSize)
{
FileSize = (uint)(pos + writtenBytes);
}
currentPageIndex += Arch.ArchDefinition.PageSize;
}
return(writtenBytes);
}
public int Read(ByteBufferRef buffer, int offset, int count, ref uint pos)
{
switch (kind)
{
case INodeKind.ArchINodeKind:
return(ArchINode.ReadImpl(buffer, offset, count, ref pos));
}
return(-ErrorCode.EINVAL);
}
public VBinderMessage(Thread from, Thread target, int label, ByteBufferRef payload, int length)
{
Contract.Ensures(GhostTarget == target);
this.from = from;
this.label = label;
this.payload = payload;
this.GhostTarget = target;
this.Length = length;
}
public VBinderMessage(Thread from, Thread target, int label, ByteBufferRef payload, int length)
{
Contract.Ensures(GhostTarget == target);
this.from = from;
this.label = label;
this.payload = payload;
this.GhostTarget = target;
this.Length = length;
}
private static void DumpUserBuf(Thread current, UserPtr writeBuf, int size)
{
var buf = new byte[(size + 3) / 4];
writeBuf.Read(current, buf, size);
var buf_ref = new ByteBufferRef(buf);
DumpBuf(new Pointer(buf_ref.Location), size);
}
public static pollfd Deserialize(ByteBufferRef buf, int offset)
{
Contract.Assert(offset >= 0 && offset + Size <= buf.Length);
pollfd res;
res.fd = Deserializer.ReadInt(buf, offset);
res.events = Deserializer.ReadShort(buf, offset + sizeof(int));
res.revents = Deserializer.ReadShort(buf, offset + sizeof(int) + sizeof(short));
return(res);
}
public static void WriteULong(ulong val, ByteBufferRef buf, int offset)
{
Contract.Requires(offset >= 0);
Contract.Requires(buf.Length >= offset + sizeof(long));
for (var i = 0; i < sizeof(long); ++i)
{
Contract.Assert(offset + i < buf.Length);
buf.Set(offset + i, (byte)((val >> (8 * i)) & 0xff));
}
}
internal void WriteInt32(int v)
{
// Fail sliently
if (cursor + sizeof(int) > Buffer.Length)
return;
var r = new ByteBufferRef(Buffer);
Deserializer.WriteInt(v, r, cursor);
cursor += sizeof(int);
}
internal BinderIPCMarshaler(Thread current, ByteBufferRef buf)
{
Contract.Requires(buf.Length >= kPatchTableSize * sizeof(int));
this.buf = buf;
this.ReadCursor = 0;
this.WriteCursor = 0;
this.current = current;
this.patchTable = new int[kPatchTableSize];
this.CurrentPatchEntry = 0;
}
public PollCompletion(Thread current, UserPtr fds, int nfds, ByteBufferRef buf)
: base(current, Kind.PollCompletionKind, buf)
{
Contract.Requires(nfds >= 0);
Contract.Requires(buf.Length >= nfds * pollfd.Size);
Contract.Ensures(fdMaps.Length == nfds);
Contract.Ensures(this.buf.Length >= fdMaps.Length * pollfd.Size);
this.userFdBuf = fds;
this.fdMaps = new int[nfds];
}
internal BinderIPCMarshaler(Thread current, ByteBufferRef buf)
{
Contract.Requires(buf.Length >= kPatchTableSize * sizeof(int));
this.buf = buf;
this.ReadCursor = 0;
this.WriteCursor = 0;
this.current = current;
this.patchTable = new int[kPatchTableSize];
this.CurrentPatchEntry = 0;
}
private int Write(Process process, Pointer dst, int length)
{
var bytesLeft = length;
var src = _value;
var dst_buf = new ByteBufferRef(dst.ToIntPtr(), length);
var cursor = 0;
while (bytesLeft > 0)
{
var region = process.Space.Find(src);
// Invalid mapping
if (region == null || region.IsFixed)
{
return(bytesLeft);
}
var off = Arch.ArchDefinition.PageOffset(src.ToUInt32());
var virtualAddr = process.Space.UserToVirt(new UserPtr(src));
if (virtualAddr == Pointer.Zero)
{
// Page isn't present, try to bring it in.
uint permission;
Pager.HandlePageFault(process, MemoryRegion.FAULT_MASK, src, Pointer.Zero, out virtualAddr, out permission);
if (virtualAddr == Pointer.Zero)
{
break;
}
}
var virtual_page = Arch.ArchDefinition.PageIndex(virtualAddr.ToUInt32());
var page_buf = new ByteBufferRef(new IntPtr(virtual_page), Arch.ArchDefinition.PageSize);
var b = Arch.ArchDefinition.PageSize - off;
var bytesTobeCopied = b > bytesLeft ? bytesLeft : b;
var dst_buf_page = page_buf.Slice(off, bytesTobeCopied);
for (var i = 0; i < bytesTobeCopied; ++i)
{
dst_buf_page.Set(i, dst_buf.Get(cursor + i));
}
bytesLeft -= bytesTobeCopied;
src += bytesTobeCopied;
cursor += bytesTobeCopied;
}
return(bytesLeft);
}
internal int SFSWrite(Thread current, ref Arch.ExceptionRegisters regs, ByteBufferRef buf, int len, uint pos, File file)
{
var writtenBytes = Write(current, buf, len, pos);
if (writtenBytes <= 0)
{
return(writtenBytes);
}
file.position = (uint)(pos + writtenBytes);
return(writtenBytes);
}
public static uint ReadUInt(ByteBufferRef buf, int offset)
{
Contract.Requires(offset >= 0);
Contract.Requires(buf.Length >= offset + sizeof(uint));
uint res = 0;
for (var i = 0; i < sizeof(uint); ++i)
{
Contract.Assert(offset + i < buf.Length);
res += (uint)buf.Get(offset + i) << (8 * i);
}
return res;
}
public static short ReadShort(ByteBufferRef buf, int offset)
{
Contract.Requires(offset >= 0);
Contract.Requires(buf.Length >= offset + sizeof(ushort));
uint res = 0;
for (var i = 0; i < sizeof(short); ++i)
{
Contract.Assert(offset + i < buf.Length);
res += (uint)buf.Get(offset + i) << (8 * i);
}
return((short)res);
}
// like strncpy, but return the number of bytes copied.
// It never add 0 to terminate the string
public static int CopyString(ref ByteBufferRef dst, int cursor, ByteBufferRef src)
{
Contract.Requires(cursor >= 0 && cursor < dst.Length);
var i = 0;
while (i + cursor < dst.Length && i < src.Length && src.Get(i) != 0)
{
Contract.Assert(i < src.Length);
dst.Set(i + cursor, src.Get(i));
++i;
}
return i;
}
public static ulong ReadUlong(ByteBufferRef buf, int offset)
{
Contract.Requires(offset >= 0);
Contract.Requires(buf.Length >= offset + sizeof(long));
ulong res = 0;
for (var i = 0; i < sizeof(long); ++i)
{
Contract.Assert(offset + i < buf.Length);
res += (ulong)buf.Get(offset + i) << (8 * i);
}
return(res);
}
internal void WriteInt32(int v)
{
// Fail sliently
if (cursor + sizeof(int) > Buffer.Length)
{
return;
}
var r = new ByteBufferRef(Buffer);
Deserializer.WriteInt(v, r, cursor);
cursor += sizeof(int);
}
private int PrepareBuffer(ByteBufferRef buf, CachePage[] sealed_page)
{
var cursor = 0;
// Metadata
for (var i = 0; i < DataPageOffset; ++i)
{
Deserializer.WriteInt(i, buf, cursor);
cursor += sizeof(int);
}
for (var i = 0; i < sealed_page.Length; ++i)
{
var pgoffset = sealed_page[i].Location;
Deserializer.WriteInt(pgoffset + DataPageOffset, buf, cursor);
cursor += sizeof(int);
if (pgoffset > MaximumPageOffset())
{
Arch.Console.WriteLine("SecureFSINode::FlushAndCloseAsync, file too big");
Utils.Panic();
return(-1);
}
}
var metadata_cursor = cursor;
cursor += DataPageOffset * Arch.ArchDefinition.PageSize;
// Copy data
var sha1 = new SHA1Managed();
for (var i = 0; i < sealed_page.Length; ++i)
{
var page = sealed_page[i];
buf.CopyFrom(cursor, page.Buffer);
sha1.Reset();
sha1.Input(page.Buffer);
var r = sha1.GetResult();
for (var j = 0; j < r.Length; ++j)
{
Signatures[page.Location * HMACSize + j] = r[j];
}
page.Dispose();
cursor += Arch.ArchDefinition.PageSize;
}
SerializeMetadata(buf, metadata_cursor);
return(0);
}
private CachePage(Process owner, int location, ByteBufferRef buf)
{
Contract.Requires(location >= 0);
Contract.Ensures(Owner == owner);
Contract.Ensures(Location == location);
Contract.Ensures(CurrentState == State.Empty);
Contract.Ensures(Next == null);
this.Owner = owner;
this.Location = location;
this.Buffer = buf;
this.Next = null;
this.CurrentState = State.Empty;
}
// Duplicated from Input(byte[])
public int Input(ByteBufferRef message_array)
{
if (message_array.Length == 0)
{
return(0);
}
var length = message_array.Length;
if (Computed)
{
Corrupted = true;
return(-1);
}
if (Corrupted)
{
return(-1);
}
int i = 0;
Contract.Assert(i + length == message_array.Length);
while (length > 0 && !Corrupted)
{
Contract.Assert(i >= 0);
Contract.Assert(i + length == message_array.Length);
Message_Block[Message_Block_Index++] = message_array.Get(i);
Length_Low += 8;
if (Length_Low == 0)
{
Length_High++;
if (Length_High == 0)
{
/* Message is too long */
Corrupted = true;
}
}
if (Message_Block_Index == 64)
{
SHA1ProcessMessageBlock();
}
i++;
length--;
}
return(0);
}
private CachePage(Process owner, int location, ByteBufferRef buf)
{
Contract.Requires(location >= 0);
Contract.Ensures(Owner == owner);
Contract.Ensures(Location == location);
Contract.Ensures(CurrentState == State.Empty);
Contract.Ensures(Next == null);
this.Owner = owner;
this.Location = location;
this.Buffer = buf;
this.Next = null;
this.CurrentState = State.Empty;
}
// like strncpy, but return the number of bytes copied.
// It never add 0 to terminate the string
public static int CopyString(ref ByteBufferRef dst, int cursor, ByteBufferRef src)
{
Contract.Requires(cursor >= 0 && cursor < dst.Length);
var i = 0;
while (i + cursor < dst.Length && i < src.Length && src.Get(i) != 0)
{
Contract.Assert(i < src.Length);
dst.Set(i + cursor, src.Get(i));
++i;
}
return(i);
}
public static int Strnlen(ByteBufferRef buf, int max_len)
{
var i = 0;
while (i < max_len && i < buf.Length)
{
if (buf.Get(i) == 0)
{
return(i);
}
++i;
}
return(i);
}
public void Write(ByteBufferRef buf, int offset)
{
Contract.Requires(offset >= 0);
Contract.Requires(offset + Size <= buf.Length);
Deserializer.WriteUInt(HandleOrPtr.Value.ToUInt32(), buf, offset); offset += sizeof(uint);
Deserializer.WriteUInt(cookie.Value.ToUInt32(), buf, offset); offset += sizeof(uint);
Deserializer.WriteUInt(code, buf, offset); offset += sizeof(uint);
Deserializer.WriteUInt(flags, buf, offset); offset += sizeof(uint);
Deserializer.WriteUInt(sender_pid, buf, offset); offset += sizeof(uint);
Deserializer.WriteUInt(sender_euid, buf, offset); offset += sizeof(uint);
Deserializer.WriteUInt(data_size, buf, offset); offset += sizeof(uint);
Deserializer.WriteUInt(offsets_size, buf, offset); offset += sizeof(uint);
Deserializer.WriteUInt(data_buffer.Value.ToUInt32(), buf, offset); offset += sizeof(uint);
Deserializer.WriteUInt(data_offsets.Value.ToUInt32(), buf, offset); offset += sizeof(uint);
}
private void SerializeMetadata(ByteBufferRef buf, int cursor)
{
Deserializer.WriteULong(HeaderMagic, buf, cursor);
cursor += sizeof(ulong);
var hmac = CalculateHMAC(DataPageOffset, FileSize, Signatures);
buf.CopyFrom(cursor, hmac);
cursor += HMACSize;
Deserializer.WriteInt(DataPageOffset, buf, cursor);
cursor += sizeof(int);
Deserializer.WriteUInt(FileSize, buf, cursor);
cursor += sizeof(uint);
Deserializer.WriteInt(Signatures.Length, buf, cursor);
cursor += sizeof(int);
buf.CopyFrom(cursor, Signatures);
}
public void Write(ByteBufferRef buf, int offset)
{
Contract.Requires(offset >= 0);
Contract.Requires(offset + Size <= buf.Length);
Deserializer.WriteUInt(HandleOrPtr.Value.ToUInt32(), buf, offset); offset += sizeof(uint);
Deserializer.WriteUInt(cookie.Value.ToUInt32(), buf, offset); offset += sizeof(uint);
Deserializer.WriteUInt(code, buf, offset); offset += sizeof(uint);
Deserializer.WriteUInt(flags, buf, offset); offset += sizeof(uint);
Deserializer.WriteUInt(sender_pid, buf, offset); offset += sizeof(uint);
Deserializer.WriteUInt(sender_euid, buf, offset); offset += sizeof(uint);
Deserializer.WriteUInt(data_size, buf, offset); offset += sizeof(uint);
Deserializer.WriteUInt(offsets_size, buf, offset); offset += sizeof(uint);
Deserializer.WriteUInt(data_buffer.Value.ToUInt32(), buf, offset); offset += sizeof(uint);
Deserializer.WriteUInt(data_offsets.Value.ToUInt32(), buf, offset); offset += sizeof(uint);
}
private static int UnmarshalDataEntries(Thread current, ByteBufferRef buf, ref sys_binder_write_desc desc)
{
var cursor = desc.read_consumed;
var i = 0;
while (i < desc.patch_table_entries && cursor < buf.Length)
{
if (cursor + 2 * sizeof(uint) > buf.Length)
{
return(-1);
}
var offset = Deserializer.ReadUInt(buf, cursor);
cursor += sizeof(uint);
var length = (int)Deserializer.ReadUInt(buf, cursor);
cursor += sizeof(int);
if (cursor + length > buf.Length)
{
return(-1);
}
//Arch.Console.Write("UnmarshalDataEntries: offset=");
//Arch.Console.Write(offset);
//Arch.Console.Write(" length=");
//Arch.Console.Write(length);
//Arch.Console.WriteLine();
//BinderIPCMarshaler.DumpBuf(marshaledPtr, length);
var b = buf.Slice(cursor, length);
if (b.Length + offset > current.Parent.binderVMSize)
{
return(-1);
}
Contract.Assert(offset + b.Length <= current.Parent.binderVMSize);
if ((current.Parent.binderVMStart + offset).Write(current, b) != 0)
{
return(-1);
}
cursor += length;
i++;
}
return(0);
}
public static binder_transaction_data Deserialize(ByteBufferRef buf, int offset)
{
Contract.Requires(offset >= 0);
Contract.Requires(offset + Size <= buf.Length);
binder_transaction_data r;
r.HandleOrPtr = new UserPtr(Deserializer.ReadUInt(buf, offset)); offset += sizeof(uint);
r.cookie = new UserPtr(Deserializer.ReadUInt(buf, offset)); offset += sizeof(uint);
r.code = Deserializer.ReadUInt(buf, offset); offset += sizeof(uint);
r.flags = Deserializer.ReadUInt(buf, offset); offset += sizeof(uint);
r.sender_pid = Deserializer.ReadUInt(buf, offset); offset += sizeof(uint);
r.sender_euid = Deserializer.ReadUInt(buf, offset); offset += sizeof(uint);
r.data_size = Deserializer.ReadUInt(buf, offset); offset += sizeof(uint);
r.offsets_size = Deserializer.ReadUInt(buf, offset); offset += sizeof(uint);
r.data_buffer = new UserPtr(Deserializer.ReadUInt(buf, offset)); offset += sizeof(uint);
r.data_offsets = new UserPtr(Deserializer.ReadUInt(buf, offset)); offset += sizeof(uint);
return r;
}
public static int UnmarshalReadBuffer(Thread thr, ByteBufferRef completionBuf, ref sys_binder_write_desc desc, UserPtr readBuffer, int readBufferSize)
{
var proc = thr.Parent;
var marshaledPtr = new Pointer(completionBuf.Location);
//Arch.Console.Write("read_consumed:");
//Arch.Console.Write(desc.read_consumed);
//BinderIPCMarshaler.DumpBuf(new Pointer(completionBuf.Location), (int)desc.read_consumed);
if (proc.binderVMStart == UserPtr.Zero)
{
Arch.Console.WriteLine("proc.binderVMStart == UserPtr.Zero");
return -ErrorCode.EFAULT;
}
if (UnmarshalDataEntries(thr, completionBuf, ref desc) != 0)
{
Arch.Console.WriteLine("UnmarshalDataEntries failed");
return -ErrorCode.ENOMEM;
}
if (desc.read_consumed > completionBuf.Length)
{
Arch.Console.WriteLine("UnmarshalReadBuffer: bad input");
return -ErrorCode.ENOMEM;
}
// Patch pointers and convert file descriptors
var b = completionBuf.Slice(0, desc.read_consumed);
if (PatchReadBuffer(thr, b) != 0)
{
Arch.Console.WriteLine("Failed to patch read buffer");
return -ErrorCode.EINVAL;
}
if (readBuffer.Write(thr, marshaledPtr, desc.read_consumed) != 0)
{
Arch.Console.WriteLine("readBuffer.Write failed");
return -ErrorCode.ENOMEM;
}
return 0;
}
public ByteBufferRef AllocPages(int pages)
{
Contract.Ensures(!Contract.Result<ByteBufferRef>().isValid ||
Contract.Result<ByteBufferRef>().Length == pages * Arch.ArchDefinition.PageSize);
var size = pages * Arch.ArchDefinition.PageSize;
var p = NativeMethods.sel4_alloc_alloc(this.handle, size);
if (p == Pointer.Zero)
{
// Post-condition of ByteBufferRef.Empty
Contract.Assume(!ByteBufferRef.Empty.isValid);
return ByteBufferRef.Empty;
}
var r = new ByteBufferRef(p.ToIntPtr(), size);
// Post-condition of ByteBufferRef
Contract.Assume(r.Length == size);
Contract.Assert(r.Length == pages * Arch.ArchDefinition.PageSize);
return r;
}
internal void WriteString16(string s)
{
var r = new ByteBufferRef(Buffer);
if (cursor + sizeof(int) > Buffer.Length)
return;
WriteInt32(s.Length);
foreach (var c in s)
{
if (cursor + sizeof(short) > r.Length)
return;
Deserializer.WriteShort((short)c, r, cursor);
cursor += sizeof(short);
}
if (cursor + sizeof(short) > r.Length)
return;
Deserializer.WriteShort(0, r, cursor);
cursor += sizeof(short);
Pad();
}
public bool Contains(ByteBufferRef buf)
{
return Start <= new Pointer(buf.Location) && new Pointer(buf.Location) + buf.Length < End;
}
public static bool StatIsDir(ByteBufferRef buf)
{
var mode = Deserializer.ReadInt(buf, OFFSET_OF_MODE_IN_STAT64);
return ((mode & S_IFMT) & S_IFDIR) != 0;
}
private int Write(Process process, Pointer dst, int length)
{
var bytesLeft = length;
var src = _value;
var dst_buf = new ByteBufferRef(dst.ToIntPtr(), length);
var cursor = 0;
while (bytesLeft > 0)
{
var region = process.Space.Find(src);
// Invalid mapping
if (region == null || region.IsFixed)
{
return bytesLeft;
}
var off = Arch.ArchDefinition.PageOffset(src.ToUInt32());
var virtualAddr = process.Space.UserToVirt(new UserPtr(src));
if (virtualAddr == Pointer.Zero)
{
// Page isn't present, try to bring it in.
uint permission;
Pager.HandlePageFault(process, MemoryRegion.FAULT_MASK, src, Pointer.Zero, out virtualAddr, out permission);
if (virtualAddr == Pointer.Zero)
break;
}
var virtual_page = Arch.ArchDefinition.PageIndex(virtualAddr.ToUInt32());
var page_buf = new ByteBufferRef(new IntPtr(virtual_page), Arch.ArchDefinition.PageSize);
var b = Arch.ArchDefinition.PageSize - off;
var bytesTobeCopied = b > bytesLeft ? bytesLeft : b;
var dst_buf_page = page_buf.Slice(off, bytesTobeCopied);
for (var i = 0; i < bytesTobeCopied; ++i)
{
dst_buf_page.Set(i, dst_buf.Get(cursor + i));
}
bytesLeft -= bytesTobeCopied;
src += bytesTobeCopied;
cursor += bytesTobeCopied;
}
return bytesLeft;
}
int Write(Process proc, ByteBufferRef val)
{
return Write(proc, new Pointer(val.Location), val.Length);
}
private unsafe int Read(Thread current, void* dst, int length)
{
var process = current.Parent;
var buf = new ByteBufferRef(new IntPtr(dst), length);
var bytesRead = Read(process, buf, false);
return length - bytesRead;
}
private int Read(Process process, ByteBufferRef buffer, bool is_string)
{
var bytesLeft = is_string ? buffer.Length - 1 : buffer.Length;
var bytesRead = 0;
var src = _value;
while (bytesLeft > 0)
{
var region = process.Space.Find(src);
// Invalid mapping
if (region == null || region.IsFixed)
break;
var off = Arch.ArchDefinition.PageOffset(src.ToUInt32());
var virtualAddr = process.Space.UserToVirt(new UserPtr(src));
if (virtualAddr == Pointer.Zero)
{
uint permission;
Pager.HandlePageFault(process, MemoryRegion.FAULT_MASK, _value, Pointer.Zero, out virtualAddr, out permission);
if (virtualAddr == Pointer.Zero)
break;
}
var virtual_page = Arch.ArchDefinition.PageIndex(virtualAddr.ToUInt32());
var page_buf = new ByteBufferRef(new IntPtr(virtual_page), Arch.ArchDefinition.PageSize);
var b = Arch.ArchDefinition.PageSize - off;
var bytesTobeCopied = b > bytesLeft ? bytesLeft : b;
var src_buf = page_buf.Slice(off, bytesTobeCopied);
if (is_string)
{
var res = Util.CopyString(ref buffer, bytesRead, src_buf);
bytesRead += res;
if (res < bytesTobeCopied)
{
// We're done.
break;
}
}
else
{
for (var i = 0; i < bytesTobeCopied; ++i)
{
buffer.Set(i + bytesRead, src_buf.Get(i));
}
bytesRead += bytesTobeCopied;
}
bytesLeft -= bytesTobeCopied;
src += bytesTobeCopied;
}
if (is_string)
{
buffer.Set(bytesRead, 0);
}
return bytesRead;
}
internal int Write(Process proc, byte[] val)
{
var b = new ByteBufferRef(val);
return Write(proc, b);
}
internal int Write(Thread current, ByteBufferRef val)
{
return Write(current.Parent, val);
}
public int ReadString(Thread current, byte[] buf)
{
var b = new ByteBufferRef(buf);
return ReadString(current, b);
}
internal unsafe int Read(Thread current, ByteBufferRef buf, int desired_length)
{
Contract.Requires(buf.Length >= desired_length);
return Read(current, buf.Location.ToPointer(), desired_length);
}
public int ReadString(Thread current, ByteBufferRef buf)
{
return Read(current.Parent, buf, true);
}
public static void SetSizeFromStat64(ByteBufferRef buf, ulong size)
{
Deserializer.WriteULong(size, buf, OFFSET_OF_SIZE_IN_STAT64);
}
public static long GetSizeFromStat64(ByteBufferRef buf)
{
return Deserializer.ReadLong(buf, OFFSET_OF_SIZE_IN_STAT64);
}
/*
* Write a segment buffer.
*
* The buffer itself is passed as a reference, because some inode might take the ownership
* of the buffer and put it as a part of its completion. In this case the buf is set to empty
*/
internal int Write(Thread current, ref Arch.ExceptionRegisters regs, ref ByteBufferRef buf, int len, uint pos, File file)
{
switch (kind)
{
case INodeKind.ConsoleINodeKind:
{
uint dummy = 0;
return ConsoleINode.WriteImpl(current, buf, len, ref dummy);
}
case INodeKind.ArchINodeKind:
case INodeKind.SocketINodeKind:
return ArchINode.ArchWrite(current, ref regs, ref buf, len, pos, file);
case INodeKind.SecureFSINodeKind:
return SFSINode.SFSWrite(current, ref regs, buf, len, pos, file);
}
return -ErrorCode.EINVAL;
}
public int Read(ByteBufferRef buffer, int offset, int count, ref uint pos)
{
switch (kind)
{
case INodeKind.ArchINodeKind:
return ArchINode.ReadImpl(buffer, offset, count, ref pos);
}
return -ErrorCode.EINVAL;
}
