Can we read another thread's program counter?

Question

0.00/5 (No votes)

See more:

assume that we have a single thread program and we hope to capture the value of program counter (PC) when a predefined interrupt occurs (like a timer interrupt).
It seems easy as you know we just write a specific assembly code using a special keyword "__asm__" and pop the value on the top of the stack after making a shift 4 byte.
What about Multithreaded programs ?
How can we get values of all threads from another thread which run in the same process? (It seems extremely incredible to get values from thread which run on a separate core in multi-core processors).
(in multithreaded programs, every thread has its stack and registers too).

-------------------------------------

C#

I would  implement a saboteur thread.
in order to perform fault injection in the target multi-threaded program, the model of fault is SEU (single error upset) which means that an arbitrary bit in the program counter register modified randomly (bit-flip) causing to violate the right program sequence. therefore, control flow error (CFE)  occurs.
Since our target program is a multi-threaded program, we have to perform fault injection on all threads' PC. This is the task of saboteur tread. It should be able  to obtain threads' PC to perform fault injection.
assume we have this code,
main ()
{
foo
}

void foo()
{
__asm__{
pop "%eax"
pop "%ebx" // now ebx holds porgram counter value (for main thread)
// her code injection like  00000111 XOR ebx for example
push ...
push ...
};
}

If our program was a multithreaded program.
is it means that we have more than one stack? 
when OS perform context switching, it means that the stack and registers of the thread that was running moved to some place in the memory. Does this mean that if we want to get the values of the program counter for those threads, we find them in memory? where? and is it possible during run-time?

any help, I am grateful to you.

What I have tried:

by using __asm__ , we can get the value of PC of the main thread.

Posted 24-Jun-16 7:03am

HusseinAl-haj

Updated 24-Jun-16 9:59am

v3

Add a Solution

2 solutions

Solution 2

It's possible to get the context, but setting it is not recommended on a running thread as behavior is unpredictable.

See GetThreadContext function (Windows)[^].

That is the only hint you're going to get and this is as far as I go. I will not help on this any further. You are on your own from this point on.

Posted 24-Jun-16 9:59am

Dave Kreskowiak

v2

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

OriginalGriff · Accepted Answer · 2016-06-24T08:12:00

Solution 1

AFAIK, no.
The problem is that you don't know when your thread is running: let alone what other thread are running at the same time. And in modern processors, that could indeed be "at the same time" - multiple cores means multiple simultaneous threads, and each core could easily be running it's thread purely from cache, so...your interrupt would only be running on one core, and you have no idea what thread is running on the other(s).
Even on a single threaded app, you have no guarantee that the core the interrupt is running on is the same core as your app!
And if a thread is stalled, it's in memory (or even paged to disk) along with its registers - and you probably won't have access to that memory, even if you know where it is because it's outside "your" address space.

Posted 24-Jun-16 8:12am

OriginalGriff

Comments

HusseinAl-haj 24-Jun-16 15:29pm

I would implement a saboteur thread.
in order to perform fault injection in the target multi-threaded program, the model of fault is SEU (single error upset) which means that an arbitrary bit in the program counter register modified randomly (bit-flip) causing to violate the right program sequence. therefore, control flow error (CFE) occurs.
Since our target program is a multi-threaded program, we have to perform fault injection on all threads' PC. This is the task of saboteur tread. It should be able to obtain threads' PC to perform fault injection.
assume we have this code,
main ()
{
foo
}

void foo()
{
__asm__{
pop "%eax"
pop "%ebx" // now ebx holds porgram counter value (for main thread)
// her code injection like 00000111 XOR ebx for example
push ...
push ...
};
}

If our program was a multithreaded program.
is it means that we have more than one stack?
when OS perform context switching, it means that the stack and registers of the thread that was running moved to some place in the memory. Does this mean that if we want to get the values of the program counter for those threads, we find them in memory? where? and is it possible during run-time?
thanks alot.