hi

Re-entrant means that function can be interrupted in the middle and called again by something else ? And then it can come back to the first call at the place where it was interrupted?
This is confusing , since I don't really see any significant difference between re-entrant function and recursive function . Why can any function be recursive ,but only few can be re-entrant ?

thank you

bye

You never know when an interrupt comes. It could be really in the middle of a printf() call, leaving it unfinished, with only half of the data written, or none yet. Am interrupt can even occur inside a statement like: leaving q partly updated with the new value. If q is a static or global variable, if the function is called another time while the first time it was interrupted while updating q in memory, then q will have an undefined value. So using q in calculations will produce wrong values.

Is that the only reason why some functions are considered unsafe in regards with re-entrance ? Because they operate on values that are either static or global ? Or they have statements that could in effect produce wrong results if interrupted (similar to example you provided) ?

thank you

As far as I know, it doesn't affect local var's. After the interrupt is handled, the function resumes exactly where it was interrupted. So the interrupted call will finish correctly. But a reentrant function should not do or change things that can affect things in other parts of the program, or the same function when it is called a second time while the first call is not yet finished. Most common "dangerous" things are changing global var's and i/o operations (like writing to a file). But also things like writing to shared memory and calling malloc() (not sure about the last one).

Changing global var's can often be handy for flagging that an interrupt arrived. This is OK if writing to the global var is done "atomically", which means that updating the var is done by one single machine (assembly) instruction, because one such instruction will not be interrupted half way, i.e. the value is assigned or not, but never half of it.

In Linux writing to a int is "atomical", so writing to a global int is save. But on other systems an int may not be good enough. To be portable you should only use globals of the type sig_atomic_t which, in Linux, will be an int. But on another system it maybe "unsigned char" for example.

But what do non re-entrant functions have ( or don't have) which makes them unsafe ?

And thank you very much for your post

bye

The exact meaning of "re-entrant function" depends on the context. In application programming, the term usually refers to a function which can be called from different threads of execution safely. This either means it doesn't modify global variables, or that it modifies them in a safe way (i.e. it checks that they are not being modified by another call of the function at that time).

Alex

thank you both for your help

bye

stupid question: what languages support this concept of re-entrant functions?
another stupid question: if a lot of processes keep calling a "re-entrant" function, would running out of stack space happen? something like buffer overflow?

first time im hearing of this (either this wasnt taught, or i musta fallen asleep when it was).

Every language that support multi-threading or signal-handling should. As llama_meme pointed out "thread safe" has a lot in common with "re-entrant".
I imagine that running out of stack could happen, but that can also happen in deep recursion. Anyways, running out of stack space is not the same as buffer overflow.

Running out of stack space is running out of stack space.
And buffer overflow is writing past stack space.
A buffer overflow can happen when there still a lot of stack space left.

hmm, thank you. learnt something there.