private static long CheckMutualExclusion(ILock @lock, int count, int cyclesCount)
{
var buckets = new long[count];
var finished = new bool[count];
var total = 0L;
ThreadId.ZeroOut();
var threads = Enumerable.Range(0, count).Select(i =>
{
return(new Thread(() =>
{
for (var j = 0; j < cyclesCount; j++)
{
@lock.Lock();
buckets[i]++;
total++;
@lock.Unlock();
}
finished[i] = true;
}));
});
foreach (var thread in threads)
{
thread.Start();
}
while (finished.Any(f => !f))
{
}
return(total);
}
/// <summary>
/// Compares this ThreadInfo object to another to determine sorting order.
/// </summary>
/// <remarks>ThreadInfo instances are sorted by their ThreadId property.</remarks>
/// <param name="other">The other ThreadInfo object to compare this object to.</param>
/// <returns>An int which is less than zero, equal to zero, or greater than zero to reflect whether
/// this ThreadInfo should sort as being less-than, equal to, or greater-than the other
/// ThreadInfo, respectively.</returns>
public int CompareTo(ThreadInfo other)
{
if (ReferenceEquals(other, null))
{
return(1); // We're not null, so we're greater than anything that is null.
}
if (ReferenceEquals(this, other))
{
return(0); // Refers to the same instance, so obviously we're equal.
}
// But in general, we compare first based on ThreadId.
int compare = ThreadId.CompareTo(other.ThreadId);
// Unfortunately, ThreadId isn't as unique as we thought, so do some follow-up compares.
if (compare == 0)
{
compare = m_Packet.ThreadIndex.CompareTo(other.ThreadIndex);
}
if (compare == 0)
{
compare = m_Packet.Timestamp.CompareTo(other.Packet.Timestamp);
}
if (compare == 0)
{
compare = m_Packet.Sequence.CompareTo(other.Packet.Sequence);
}
if (compare == 0)
{
compare = Id.CompareTo(other.Id); // Finally, compare by Guid if we have to.
}
return(compare);
}
public void VirtualMachineStart(Types.SuspendPolicy suspendPolicy, RequestId requestId, ThreadId threadId)
{
ThreadReference thread = VirtualMachine.GetMirrorOf(threadId);
EventRequest request = VirtualMachine.EventRequestManager.GetEventRequest(EventKind.VirtualMachineStart, requestId);
ThreadEventArgs e = new ThreadEventArgs(VirtualMachine, (SuspendPolicy)suspendPolicy, request, thread);
VirtualMachine.EventQueue.OnVirtualMachineStart(e);
}
/// <summary>
/// Default ctor
/// </summary>
internal DebugThread(DebugProgram program, EngineEventCallback eventCallback, ThreadManager manager, ThreadId threadId, int tid)
: base(threadId, manager)
{
this.program = program;
this.eventCallback = eventCallback;
this.tid = tid;
}
/// <summary>
/// Handle Thread Status messages
/// </summary>
internal static void HandleTHST(Chunk chunk, Action <DalvikEvent> onEvent)
{
var data = chunk.Data;
var hdrLength = data.GetByte();
var entryLen = data.GetByte();
var count = data.GetInt16();
data.Skip(hdrLength - 4);
var list = new List <ThreadStatusInfo>();
for (var i = 0; i < count; i++)
{
var id = new ThreadId(data, 4);
var state = data.GetByte();
var tid = data.GetInt();
var utime = data.GetInt();
var stime = data.GetInt();
var isDaemon = data.GetByte();
data.Skip(entryLen - 18);
DLog.Debug(DContext.DebuggerLibEvent, "THST id={0}, state={1}, tid={2}, utime={3}, stime={4}", id, state, tid, utime, stime);
list.Add(new ThreadStatusInfo(id, (ThreadStates)state));
}
onEvent(new ThreadStatus(list));
}
/// <summary>
/// Try to get a thread by it's id.
/// </summary>
public bool TryGet(ThreadId id, out DalvikThread thread)
{
lock (threadsLock)
{
return threads.TryGetValue(id, out thread);
}
}
/// <summary>
/// Returns the value of one or more local variables in a given frame. Each variable must be visible at the frame's code index.
/// Even if local variable information is not available, values can be retrieved if the front-end is able to determine the correct
/// local variable index. (Typically, this index can be determined for method arguments from the method signature without access to
/// the local variable table information.)
/// </summary>
public Task<List<Value>> GetValuesAsync(ThreadId threadId, FrameId frameId, SlotRequest[] slots)
{
var conn = ConnectionOrError;
DLog.Debug(DContext.DebuggerLibCommands, () => string.Format("StackFrame.GetValues {0}", string.Join(", ", slots.Select(x => x.ToString()))));
var t = conn.SendAsync(JdwpPacket.CreateCommand(conn, Nr, 1, threadId.Size + frameId.Size + 4 + (slots.Length * 5),
x => {
var data = x.Data;
threadId.WriteTo(data);
frameId.WriteTo(data);
data.SetInt(slots.Length);
foreach (var slot in slots)
{
data.SetInt(slot.Slot);
data.SetByte((byte) slot.Tag);
}
}));
return t.ContinueWith(x => {
x.ForwardException();
var result = x.Result;
result.ThrowOnError();
var data = result.Data;
var count = data.GetInt();
var list = new List<Value>(count);
for (var i = 0; i < count; i++ )
{
var value = new Value(data);
list.Add(value);
}
return list;
});
}
/// <summary>
/// Gets the current call stack of the thread with given id.
/// </summary>
public Task<List<Tuple<FrameId, Location>>> FramesAsync(ThreadId id, int length = -1)
{
var conn = ConnectionOrError;
var sizeInfo = conn.GetIdSizeInfo();
var t = conn.SendAsync(JdwpPacket.CreateCommand(conn, Nr, 6, sizeInfo.ObjectIdSize + 8,
x => {
id.WriteTo(x.Data);
x.Data.SetInt(0); // start frame
x.Data.SetInt(length); // length -1 == all
}));
return t.ContinueWith(x => {
x.ForwardException();
var result = x.Result;
result.ThrowOnError();
var count = result.Data.GetInt();
var list = new List<Tuple<FrameId, Location>>(count);
for (var i = 0; i < count; i++)
{
var frame = new FrameId(result.Data, sizeInfo);
var location = new Location(result.Data);
list.Add(Tuple.Create(frame, location));
}
return list;
});
}
internal int GetSuspendCount(ThreadId threadId)
{
int result;
VirtualMachine.SuspendCounts.TryGetValue(threadId, out result);
return(result);
}
/// <summary>
/// 接收
/// </summary>
public void receive()
{
string filename = frm.fileNames[ThreadId]; // 线程临时文件
byte[] buffer = new byte[_bufferSize]; // 接收缓冲区
int readSize = 0; // 接收字节数
FileStream fs = new FileStream(filename, System.IO.FileMode.Create);
Stream ns = null;
Console.WriteLine("线程[" + ThreadId.ToString() + "] 开始接收......");
try
{
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(Url);
request.AddRange(frm.StartPos[ThreadId], frm.StartPos[ThreadId] + frm.fileSize[ThreadId]);
ns = request.GetResponse().GetResponseStream();
readSize = ns.Read(buffer, 0, _bufferSize);
Console.WriteLine("线程[" + ThreadId.ToString() + "] 正在接收 " + readSize);
while (readSize > 0)
{
fs.Write(buffer, 0, readSize);
readSize = ns.Read(buffer, 0, _bufferSize);
// Console.WriteLine("线程[" + ThreadId.ToString() + "] 正在接收 " + readSize);
}
fs.Close();
ns.Close();
}
catch (Exception er)
{
MessageBox.Show(er.Message);
fs.Close();
}
Console.WriteLine("进程[" + ThreadId.ToString() + "] 结束!");
frm.threadStatus[ThreadId] = true;
}
public int CompareTo(Job other)
{
//EndOfProcessing of processin then thread id
return((EndOfProcessing == other.EndOfProcessing)
? ThreadId.CompareTo(other.ThreadId)
: EndOfProcessing.CompareTo(other.EndOfProcessing));
}
/// <summary>
/// Abstracts and returns the spawned thread.
/// </summary>
/// <param name="parent">Parent</param>
/// <param name="impl">Implementation</param>
/// <param name="tidExpr">Expr</param>
/// <param name="spawner">CallCmd</param>
private Thread GetAbstractSpawnedThread(Thread parent, Implementation impl, Expr tidExpr, CallCmd spawner)
{
ThreadId tid = this.GetAbstractThreadId(tidExpr, impl, spawner);
string threadName = "";
if (spawner.Ins[2] is IdentifierExpr)
{
threadName = (spawner.Ins[2] as IdentifierExpr).Name;
}
else if (spawner.Ins[2] is NAryExpr)
{
var threadExpr = spawner.Ins[2] as NAryExpr;
if (threadExpr.Fun.FunctionName.StartsWith("$bitcast."))
{
threadName = (threadExpr.Args[0] as IdentifierExpr).Name;
}
}
var thread = Thread.Create(this.AC, tid, threadName, spawner.Ins[3], parent);
parent.AddChild(thread);
if (ToolCommandLineOptions.Get().SuperVerboseMode)
{
Output.PrintLine("..... {0} spawns {1}",
parent, thread);
}
return(thread);
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="threadId">The ID of the database.</param>
/// <param name="listenOptions">The human-readable name for the database.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
/// <returns></returns>
public async IAsyncEnumerable <ListenAction <T> > ListenAsync <T>(ThreadId threadId, IEnumerable <ListenOption> listenOptions, [EnumeratorCancellation] CancellationToken cancellationToken = default)
{
ListenRequest request = new()
{
DbID = ByteString.CopyFrom(threadId.Bytes),
};
IEnumerable <ListenRequest.Types.Filter> filters = listenOptions.Select(o =>
new ListenRequest.Types.Filter()
{
CollectionName = o.CollectionName,
InstanceID = o.InstanceId ?? string.Empty,
Action = (ListenRequest.Types.Filter.Types.Action)o.Action
});
request.Filters.AddRange(filters);
using AsyncServerStreamingCall <ListenReply> call = _apiClient.Listen(request, headers: _threadContext.Metadata, cancellationToken: cancellationToken);
await foreach (ListenReply message in call.ResponseStream.ReadAllAsync(cancellationToken))
{
if (message != null)
{
ListenAction <T> action = new()
{
Collection = message.CollectionName,
Action = (ActionType)message.Action,
InstanceId = message.InstanceID,
Instance = JsonSerializer.Deserialize <T>(message.Instance.ToStringUtf8())
};
yield return(action);
}
}
}
public Transaction(Context.IThreadContext threadContext, API.APIClient apiClient, ThreadId threadId, string collectionName)
{
this.ThreadContext = threadContext;
Client = apiClient;
ThreadId = threadId;
CollectionName = collectionName;
}
/// <summary>
/// Try to get a thread by it's id.
/// </summary>
public bool TryGet(ThreadId id, out DalvikThread thread)
{
lock (threadsLock)
{
return(threads.TryGetValue(id, out thread));
}
}
/// <summary>
///
/// </summary>
/// <param name="address"></param>
/// <param name="key"></param>
/// <param name="collections"></param>
/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
/// <returns></returns>
public async Task <ThreadId> NewDbFromAdd(string address, string key, IList <Models.CollectionInfo> collections, CancellationToken cancellationToken = default)
{
Multiaddress addr = Multiaddress.Decode(address);
byte[] keyBytes = ThreadKey.FromString(key).Bytes;
NewDBFromAddrRequest request = new()
{
Addr = ByteString.CopyFrom(addr.ToBytes()),
Key = ByteString.CopyFrom(keyBytes)
};
if (collections != null)
{
//TODO: Finish mapping
request.Collections.AddRange(collections.Select(c =>
{
return(_mapper.Map <Grpc.CollectionConfig>(c));
}).ToArray());
}
await _apiClient.NewDBFromAddrAsync(request, headers : _threadContext.Metadata, cancellationToken : cancellationToken);
//TODO: Get the threadID and Address
string threadId = string.Empty;
return(ThreadId.FromString(threadId));
}
/// <summary>
///
/// </summary>
/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
/// <returns></returns>
public async Task <IDictionary <string, GetDBInfoReply> > ListDBsAsync(CancellationToken cancellationToken = default)
{
ListDBsRequest request = new();
ListDBsReply list = await _apiClient.ListDBsAsync(request, headers : _threadContext.Metadata, cancellationToken : cancellationToken);
return(list.Dbs.ToDictionary(db => ThreadId.FromBytes(db.DbID.ToByteArray()).ToString(), db => db.Info));
}
public static ThreadId GetThreadId(Thread handle)
{
ThreadId threadId = ThreadId.Worker;
try { threadId = threadLibrary[handle]; }
catch (Exception) { }
return(threadId);
}
public ServerThread([NotNull] Settings settings, [NotNull] ThreadId threadId, [NotNull] DistLogger logger, [NotNull] DistLogger errorLogger)
{
_settings = settings;
_threadId = threadId;
_logger = logger;
_errorLogger = errorLogger;
logger.Info("Initializing Server", _threadId);
}
public static EventRequestModifier ThreadFilter(ThreadId thread)
{
return new EventRequestModifier()
{
Kind = ModifierKind.ThreadFilter,
Thread = thread,
};
}
public void Should_Be_Able_To_Create_A_RandomID()
{
ThreadId i = ThreadId.FromRandom(Variant.Raw, 16);
Assert.NotNull(i);
Assert.Equal(18, i.Bytes.Length);
Assert.True(i.IsDefined);
}
public override int GetHashCode()
{
unchecked
{
int hash = 17;
hash = hash * 23 + TitleUnicode.GetHashCode();
hash = hash * 23 + TitleRoman.GetHashCode();
hash = hash * 23 + ArtistUnicode.GetHashCode();
hash = hash * 23 + ArtistRoman.GetHashCode();
hash = hash * 23 + Creator.GetHashCode();
hash = hash * 23 + DiffName.GetHashCode();
hash = hash * 23 + Mp3Name.GetHashCode();
hash = hash * 23 + Md5.GetHashCode();
hash = hash * 23 + OsuFileName.GetHashCode();
hash = hash * 23 + Tags.GetHashCode();
hash = hash * 23 + Somestuff.GetHashCode();
hash = hash * 23 + _state.GetHashCode();
hash = hash * 23 + Circles.GetHashCode();
hash = hash * 23 + Sliders.GetHashCode();
hash = hash * 23 + Spinners.GetHashCode();
hash = hash * 23 + EditDate.GetHashCode();
hash = hash * 23 + ApproachRate.GetHashCode();
hash = hash * 23 + CircleSize.GetHashCode();
hash = hash * 23 + HpDrainRate.GetHashCode();
hash = hash * 23 + OverallDifficulty.GetHashCode();
hash = hash * 23 + SliderVelocity.GetHashCode();
hash = hash * 23 + DrainingTime.GetHashCode();
hash = hash * 23 + TotalTime.GetHashCode();
hash = hash * 23 + PreviewTime.GetHashCode();
hash = hash * 23 + MapId.GetHashCode();
hash = hash * 23 + MapSetId.GetHashCode();
hash = hash * 23 + ThreadId.GetHashCode();
hash = hash * 23 + OsuGrade.GetHashCode();
hash = hash * 23 + TaikoGrade.GetHashCode();
hash = hash * 23 + CatchGrade.GetHashCode();
hash = hash * 23 + ManiaGrade.GetHashCode();
hash = hash * 23 + Offset.GetHashCode();
hash = hash * 23 + StackLeniency.GetHashCode();
hash = hash * 23 + PlayMode.GetHashCode();
hash = hash * 23 + Source.GetHashCode();
hash = hash * 23 + AudioOffset.GetHashCode();
hash = hash * 23 + LetterBox.GetHashCode();
hash = hash * 23 + Played.GetHashCode();
hash = hash * 23 + LastPlayed.GetHashCode();
hash = hash * 23 + IsOsz2.GetHashCode();
hash = hash * 23 + Dir.GetHashCode();
//hash = hash * 23 + LastSync.GetHashCode(); //This value is updated by osu even if no changes were made to the actual data
hash = hash * 23 + DisableHitsounds.GetHashCode();
hash = hash * 23 + DisableSkin.GetHashCode();
hash = hash * 23 + DisableSb.GetHashCode();
hash = hash * 23 + BgDim.GetHashCode();
hash = hash * 23 + ModPpStars.GetHashCode();
hash = hash * 23 + MaxBpm.GetHashCode();
hash = hash * 23 + MinBpm.GetHashCode();
hash = hash * 23 + MainBpm.GetHashCode();
return(hash);
}
}
public void Should_Be_Able_To_Round_Trip_To_And_From_Bytes()
{
ThreadId i = ThreadId.FromRandom(Variant.Raw, 16);
byte[] b = i.Bytes;
ThreadId n = ThreadId.FromBytes(b);
Assert.Equal(n, i);
}
/// <summary>
///
/// </summary>
/// <param name="threadId">The ID of the database.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
/// <returns></returns>
public async Task DeleteDBAsync(ThreadId threadId, CancellationToken cancellationToken = default)
{
DeleteDBRequest request = new()
{
DbID = ByteString.CopyFrom(threadId.Bytes)
};
await _apiClient.DeleteDBAsync(request, headers : _threadContext.Metadata, cancellationToken : cancellationToken);
}
internal ThreadReference GetMirrorOf(ThreadId thread)
{
if (thread == default(ThreadId))
{
return(null);
}
return(new ThreadReference(this, thread));
}
public void Breakpoint(Types.SuspendPolicy suspendPolicy, RequestId requestId, ThreadId threadId, Types.Location location)
{
ThreadReference thread = VirtualMachine.GetMirrorOf(threadId);
EventRequest request = VirtualMachine.EventRequestManager.GetEventRequest(EventKind.Breakpoint, requestId);
Location loc = VirtualMachine.GetMirrorOf(location);
ThreadLocationEventArgs e = new ThreadLocationEventArgs(VirtualMachine, (SuspendPolicy)suspendPolicy, request, thread, loc);
VirtualMachine.EventQueue.OnBreakpoint(e);
}
protected virtual void doWork()
{
ThreadState = System.Threading.ThreadState.Running;
m_SimpleMethod();
ThreadState = System.Threading.ThreadState.Stopped;
if (threadCallback != null)
{
threadCallback(ThreadId.ToString());
}
}
protected virtual void doWorkP(object parms)
{
ThreadState = System.Threading.ThreadState.Running;
m_ParamMethod(parms);
ThreadState = System.Threading.ThreadState.Stopped;
if (threadCallback != null)
{
threadCallback(ThreadId.ToString());
}
}
/// <summary>
///
/// </summary>
/// <param name="threadId">The ID of the database.</param>
/// <param name="config"></param>
/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
/// <returns></returns>
public async Task UpdateCollectionAsync(ThreadId threadId, Models.CollectionInfo config, CancellationToken cancellationToken = default)
{
UpdateCollectionRequest request = new()
{
Config = _mapper.Map <Grpc.CollectionConfig>(config),
DbID = ByteString.CopyFrom(threadId.Bytes)
};
await _apiClient.UpdateCollectionAsync(request, headers : _threadContext.Metadata, cancellationToken : cancellationToken);
}
public void Log(string logInfo)
{
if (_logUtility == null)
{
_logUtility = new LogUtility();
}
string str = string.Format("Thread {0}: {1}", ThreadId.ToString(), logInfo);
_logUtility.Log(str);
}
/// <summary>
/// Abstracts the blocked thread.
/// </summary>
/// <param name="parent">Parent</param>
/// <param name="impl">Implementation</param>
/// <param name="tidExpr">Expr</param>
/// <param name="spawner">CallCmd</param>
private void AbstractBlockedThread(Thread parent, Implementation impl, Expr tidExpr, CallCmd spawner)
{
ThreadId tid = this.GetAbstractThreadId(tidExpr, impl, spawner);
if (ToolCommandLineOptions.Get().SuperVerboseMode)
{
Output.PrintLine("..... {0} blocks unidentified thread with id '{1}'",
parent, tid.Id);
}
}
public override string ToString()
{
var t = ThreadId.ToString();
if (t.Length == 1)
{
t = $"{t} ";
}
return($"[{t}] {Message}");
}
/// <summary>
/// Resume the thread with given id.
/// </summary>
public Task ResumeAsync(ThreadId id)
{
var conn = ConnectionOrError;
var sizeInfo = conn.GetIdSizeInfo();
var t = conn.SendAsync(JdwpPacket.CreateCommand(conn, Nr, 3, sizeInfo.ObjectIdSize, x => id.WriteTo(x.Data)));
return t.ContinueWith(x => {
x.ForwardException();
var result = x.Result;
result.ThrowOnError();
});
}
public override string ToString()
{
return(string.Format(DefaultNumberedMessageFormat,
ThreadHashCode.ToString(),
ThreadId.ToString(),
ApplicationName,
ProcessId,
Utc.ToShortDateString(),
Utc.ToShortTimeString(),
Message));
}
/// <summary>
///
/// </summary>
/// <param name="threadId">The ID of the database.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
/// <returns></returns>
public async Task <IList <Models.CollectionInfo> > ListCollectionAsync(ThreadId threadId, CancellationToken cancellationToken = default)
{
ListCollectionsRequest request = new()
{
DbID = ByteString.CopyFrom(threadId.Bytes)
};
ListCollectionsReply reply = await _apiClient.ListCollectionsAsync(request, headers : _threadContext.Metadata, cancellationToken : cancellationToken);
return(_mapper.Map <List <Models.CollectionInfo> >(reply.Collections.ToList()));
}
public override int GetHashCode()
{
unchecked
{
var hashCode = (Id != null ? Id.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (ThreadId != null ? ThreadId.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (CommentText != null ? CommentText.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (Sender != null ? Sender.GetHashCode() : 0);
return(hashCode);
}
}
public void Save()
{
Query savePost = new Query("INSERT INTO POSTS (thread_id, subject, message, poster, image) VALUES(@ThreadId, @Subject, @Message, @Poster, @Image)");
savePost.AddParameter("@ThreadId", ThreadId.ToString());
savePost.AddParameter("@Subject", Subject);
savePost.AddParameter("@Message", Message);
savePost.AddParameter("@Poster", Poster);
savePost.AddParameter("@Image", Image);
savePost.Execute();
Console.WriteLine("SUBJECT: " + Subject);
}
public IJsonValue ExportToJsonObject()
{
var buffer = new JsonObject();
buffer.SetNamedValue("Id", Id.ToJsonValue());
buffer.SetNamedValue("Timestamp", Timestamp.ToJsonValue());
buffer.SetNamedValue("ThreadId", ThreadId.ToJsonValue());
buffer.SetNamedValue("Severity", Severity.ToJsonValue());
buffer.SetNamedValue("Message", Message.ToJsonValue());
return(buffer);
}
/// <summary>
/// Returns the value of one or more local variables in a given frame. Each variable must be visible at the frame's code index.
/// Even if local variable information is not available, values can be retrieved if the front-end is able to determine the correct
/// local variable index. (Typically, this index can be determined for method arguments from the method signature without access to
/// the local variable table information.)
/// </summary>
public Task<List<Value>> GetValuesAsync(ThreadId threadId, FrameId frameId, SlotRequest[] slots)
{
var conn = ConnectionOrError;
DLog.Debug(DContext.DebuggerLibCommands, () => string.Format("StackFrame.GetValues {0}", string.Join(", ", slots.Select(x => x.ToString()))));
var t = conn.SendAsync(JdwpPacket.CreateCommand(conn, Nr, 1, threadId.Size + frameId.Size + 4 + (slots.Length * 5),
x => {
var data = x.Data;
threadId.WriteTo(data);
frameId.WriteTo(data);
data.SetInt(slots.Length);
foreach (var slot in slots)
{
if (slot.Slot == 1000)
{
// I have seen this crash the VM on a CyanogenMod Android 4.4.4
// Samsung GT-I9195. Might be a bug in CyanogenMod.
// https://android.googlesource.com/platform/art/+/ffcd9d25199a944625bd3c9a766349c23dcbdb66/runtime/debugger.cc
DLog.Debug(DContext.DebuggerLibEvent, "accessing variable with Slot=1000");
}
data.SetInt(slot.Slot);
data.SetByte((byte) slot.Tag);
}
}));
return t.ContinueWith(x => {
x.ForwardException();
var result = x.Result;
result.ThrowOnError();
var data = result.Data;
var count = data.GetInt();
var list = new List<Value>(count);
for (var i = 0; i < count; i++ )
{
var value = new Value(data);
list.Add(value);
}
return list;
});
}
internal ThreadReference(VirtualMachine virtualMachine, ThreadId threadId, IReferenceType threadType)
: base(virtualMachine, threadId, threadType)
{
Contract.Requires(virtualMachine != null);
}
public Error SetValues(ThreadId thread, FrameId frame, int[] slots, Value[] values)
{
int frameIndex = (int)frame.Handle;
FrameLocationData[] frames = new FrameLocationData[1];
Error errorCode = GetRawThreadFrames(out frames, thread, frameIndex, 1);
if (errorCode != Error.None)
return errorCode;
frame = frames[0].FrameId;
throw new NotImplementedException();
}
public Error GetThisObject(out TaggedObjectId thisObject, ThreadId thread, FrameId frame)
{
int frameIndex = (int)frame.Handle;
FrameLocationData[] frames = new FrameLocationData[1];
Error errorCode = GetRawThreadFrames(out frames, thread, frameIndex, 1);
if (errorCode != Error.None)
{
thisObject = default(TaggedObjectId);
return errorCode;
}
frame = frames[0].FrameId;
byte[] packet = new byte[HeaderSize + ThreadIdSize + FrameIdSize];
int id = GetMessageId();
SerializeHeader(packet, id, StackFrameCommand.ThisObject);
WriteObjectId(packet, HeaderSize, thread);
WriteFrameId(packet, HeaderSize + ThreadIdSize, frame);
byte[] response = SendPacket(id, packet);
errorCode = ReadErrorCode(response);
if (errorCode != Error.None)
{
thisObject = default(TaggedObjectId);
return errorCode;
}
int offset = HeaderSize;
thisObject = ReadTaggedObjectId(response, ref offset);
return Error.None;
}
public void MethodEntry(Types.SuspendPolicy suspendPolicy, RequestId requestId, ThreadId thread, Types.Location location)
{
throw new NotImplementedException();
}
public Error GetValues(out Value[] values, ThreadId thread, FrameId frame, int[] slots)
{
int frameIndex = (int)frame.Handle;
FrameLocationData[] frames = new FrameLocationData[1];
Error errorCode = GetRawThreadFrames(out frames, thread, frameIndex, 1);
if (errorCode != Error.None)
{
values = null;
return errorCode;
}
frame = frames[0].FrameId;
VariableData[] variableData;
errorCode = GetMethodVariableTable(out variableData, frames[0].Location.Class, frames[0].Location.Method);
if (errorCode != Error.None)
{
values = null;
return errorCode;
}
Tag[] tags = new Tag[slots.Length];
for (int i = 0; i < slots.Length; i++)
{
tags[i] = Tag.Object;
foreach (VariableData variable in variableData)
{
if (variable.Slot != slots[i])
continue;
if (variable.CodeIndex > frames[0].Location.Index)
continue;
if (variable.CodeIndex + variable.Length <= frames[0].Location.Index)
continue;
if (string.IsNullOrEmpty(variable.Signature))
continue;
tags[i] = (Tag)variable.Signature[0];
break;
}
}
byte[] packet = new byte[HeaderSize + ThreadIdSize + FrameIdSize + sizeof(int) + (slots.Length * (sizeof(int) + sizeof(byte)))];
int id = GetMessageId();
SerializeHeader(packet, id, StackFrameCommand.GetValues);
WriteObjectId(packet, HeaderSize, thread);
WriteFrameId(packet, HeaderSize + ThreadIdSize, frame);
WriteInt32(packet, HeaderSize + ThreadIdSize + FrameIdSize, slots.Length);
int baseOffset = HeaderSize + ThreadIdSize + FrameIdSize + sizeof(int);
for (int i = 0; i < slots.Length; i++)
{
int slotOffset = baseOffset + i * (sizeof(int) + sizeof(byte));
WriteInt32(packet, slotOffset, slots[i]);
packet[slotOffset + sizeof(int)] = (byte)tags[i];
}
byte[] response = SendPacket(id, packet);
errorCode = ReadErrorCode(response);
if (errorCode != Error.None)
{
values = null;
return errorCode;
}
int offset = HeaderSize;
int valueCount = ReadInt32(response, ref offset);
values = new Value[valueCount];
for (int i = 0; i < valueCount; i++)
{
values[i] = ReadValue(response, ref offset);
}
return Error.None;
}
private jvmtiError ApplySuspendPolicy(JvmtiEnvironment environment, JniEnvironment nativeEnvironment, SuspendPolicy policy, ThreadId eventThread)
{
if (policy == SuspendPolicy.EventThread && eventThread == default(ThreadId))
{
return jvmtiError.InvalidThread;
}
switch (policy)
{
case SuspendPolicy.None:
return jvmtiError.None;
case SuspendPolicy.EventThread:
return environment.SuspendThread(nativeEnvironment, eventThread);
case SuspendPolicy.All:
ThreadId[] requestList;
JvmtiErrorHandler.ThrowOnFailure(environment.GetAllThreads(nativeEnvironment, out requestList));
jvmtiError[] errors;
return environment.SuspendThreads(nativeEnvironment, requestList, out errors);
default:
throw new ArgumentException("Invalid suspend policy.");
}
}
public Error GetAllThreads(out ThreadId[] threads)
{
byte[] packet = new byte[HeaderSize];
int id = GetMessageId();
SerializeHeader(packet, id, VirtualMachineCommand.AllThreads);
byte[] response = SendPacket(id, packet);
Error errorCode = ReadErrorCode(response);
if (errorCode != Error.None)
{
threads = null;
return errorCode;
}
int offset = HeaderSize;
int threadCount = ReadInt32(response, ref offset);
threads = new ThreadId[threadCount];
for (int i = 0; i < threadCount; i++)
threads[i] = (ThreadId)ReadObjectId(response, ref offset);
return Error.None;
}
public Error GetThreadSuspendCount(out int suspendCount, ThreadId thread)
{
byte[] packet = new byte[HeaderSize + ThreadIdSize];
int id = GetMessageId();
SerializeHeader(packet, id, ThreadReferenceCommand.SuspendCount);
WriteObjectId(packet, HeaderSize, thread);
byte[] response = SendPacket(id, packet);
Error errorCode = ReadErrorCode(response);
if (errorCode != Error.None)
{
suspendCount = 0;
return errorCode;
}
int offset = HeaderSize;
suspendCount = ReadInt32(response, ref offset);
return Error.None;
}
public void MonitorContendedWaited(Types.SuspendPolicy suspendPolicy, RequestId requestId, ThreadId thread, TaggedObjectId @object, Types.Location location, bool timedOut)
{
throw new NotImplementedException();
}
/// <summary>
/// Create an instance representing the given reference type.
/// </summary>
protected virtual DalvikThread CreateThread(ThreadId id)
{
return new DalvikThread(id, this);
}
public void ClassPrepare(Types.SuspendPolicy suspendPolicy, RequestId requestId, ThreadId threadId, TypeTag typeTag, ReferenceTypeId typeId, string signature, ClassStatus status)
{
ThreadReference thread = VirtualMachine.GetMirrorOf(threadId);
EventRequest request = VirtualMachine.EventRequestManager.GetEventRequest(EventKind.ClassPrepare, requestId);
ReferenceType type = VirtualMachine.GetMirrorOf(typeTag, typeId);
ClassPrepareEventArgs e = new ClassPrepareEventArgs(VirtualMachine, (SuspendPolicy)suspendPolicy, request, thread, signature, type);
VirtualMachine.EventQueue.OnClassPrepare(e);
}
public void FieldModification(Types.SuspendPolicy suspendPolicy, RequestId requestId, ThreadId thread, Types.Location location, TypeTag typeTag, ReferenceTypeId typeId, FieldId field, TaggedObjectId @object, Types.Value newValue)
{
throw new NotImplementedException();
}
private void SendClassPrepareEvent(JvmtiEnvironment environment, EventFilter filter, ThreadId threadId, TaggedReferenceTypeId classId, string signature, ClassStatus classStatus, bool preventSuspend)
{
if (!VirtualMachine.IsAgentThread.Value)
{
// ignore events before VMInit
if (AgentEventDispatcher == null)
return;
// dispatch this call to an agent thread
Action<JvmtiEnvironment, EventFilter, ThreadId, TaggedReferenceTypeId, string, ClassStatus, bool> method = SendClassPrepareEvent;
AgentEventDispatcher.Invoke(method, environment, filter, threadId, classId, signature, classStatus, preventSuspend);
return;
}
JniEnvironment nativeEnvironment;
JniErrorHandler.ThrowOnFailure(VirtualMachine.AttachCurrentThreadAsDaemon(environment, out nativeEnvironment, true));
SuspendPolicy suspendPolicy = preventSuspend ? SuspendPolicy.None : filter.SuspendPolicy;
if (!preventSuspend)
ApplySuspendPolicy(environment, nativeEnvironment, filter.SuspendPolicy, threadId);
Callback.ClassPrepare(suspendPolicy, filter.RequestId, threadId, classId.TypeTag, classId.TypeId, signature, classStatus);
}
public Error GetThreadGroupChildren(out ThreadId[] childThreads, out ThreadGroupId[] childGroups, ThreadGroupId group)
{
throw new NotImplementedException();
}
private void SendSingleStepEvent(JvmtiEnvironment environment, EventFilter filter, ThreadId threadId, Location location)
{
if (!VirtualMachine.IsAgentThread.Value)
{
// ignore events before VMInit
if (AgentEventDispatcher == null)
return;
// dispatch this call to an agent thread
Action<JvmtiEnvironment, EventFilter, ThreadId, Location> invokeMethod = SendSingleStepEvent;
AgentEventDispatcher.Invoke(invokeMethod, environment, filter, threadId, location);
return;
}
JniEnvironment nativeEnvironment;
JniErrorHandler.ThrowOnFailure(VirtualMachine.AttachCurrentThreadAsDaemon(environment, out nativeEnvironment, false));
ApplySuspendPolicy(environment, nativeEnvironment, filter.SuspendPolicy, threadId);
Callback.SingleStep(filter.SuspendPolicy, filter.RequestId, threadId, location);
}
public void MethodExit(Types.SuspendPolicy suspendPolicy, RequestId requestId, ThreadId thread, Types.Location location, Types.Value returnValue)
{
throw new NotImplementedException();
}
public Error PopFrames(ThreadId thread, FrameId frame)
{
int frameIndex = (int)frame.Handle;
FrameLocationData[] frames = new FrameLocationData[1];
Error errorCode = GetRawThreadFrames(out frames, thread, frameIndex, 1);
if (errorCode != Error.None)
return errorCode;
frame = frames[0].FrameId;
byte[] packet = new byte[HeaderSize + ThreadIdSize + FrameIdSize];
int id = GetMessageId();
SerializeHeader(packet, id, StackFrameCommand.PopFrames);
WriteObjectId(packet, HeaderSize, thread);
WriteFrameId(packet, HeaderSize + ThreadIdSize, frame);
byte[] response = SendPacket(id, packet);
return ReadErrorCode(response);
}
public void Exception(Types.SuspendPolicy suspendPolicy, RequestId requestId, ThreadId threadId, Types.Location location, TaggedObjectId exception, Types.Location catchLocation)
{
EventRequest request = VirtualMachine.EventRequestManager.GetEventRequest(EventKind.Exception, requestId);
ThreadReference thread = VirtualMachine.GetMirrorOf(threadId);
Location loc = VirtualMachine.GetMirrorOf(location);
ObjectReference exceptionReference = VirtualMachine.GetMirrorOf(exception);
Location catchLoc = VirtualMachine.GetMirrorOf(catchLocation);
ExceptionEventArgs e = new ExceptionEventArgs(VirtualMachine, (SuspendPolicy)suspendPolicy, request, thread, loc, exceptionReference, catchLoc);
VirtualMachine.EventQueue.OnException(e);
}
public Error StopThread(ThreadId thread, ObjectId throwable)
{
throw new NotImplementedException();
}
public Error GetThreadCurrentContendedMonitor(out TaggedObjectId monitor, ThreadId thread)
{
throw new NotImplementedException();
}
public Error InterruptThread(ThreadId thread)
{
throw new NotImplementedException();
}
