Tracing of function calls in C

I'm developing some modules for an automation system written in C and I need to perform lots of work with hardware. And I see no simple way (like traditional) to debugging things instead of trace logs. So I'm looking for a good practice to log function calls. At least the sequence of calls and return values.

The way it is performed in application is quite straightforward and actually pollutes the code with irrelevant constructions like

int function (int param){
   if(trace_level & LOG_FCALLS){
      writelog("Entering function()");
   }

   /* something useful */

   if(trace_level & LOG_FCALLS){
      writelog("Exit from function()=%d", ret);
   }
}

I decided to use a macro that will do all the dirty work. Now it looks like this

#define LOG_E(fn) const char *__fname=fn;  printf("LOG: Entry to %s\n",__fname)
#define return(ret)     printf("LOG: Exit from %s()=%d\n",__fname,ret)

int testFunc(){
   LOG_E("testFunc");

   /*do useful things */

   return(ret);
}

I see the problems with this code

1. 
   

   I'm overriding return statement, and it is requires to write return(ret) all the time instead of return ret. It is easy to forget this issue.

   
   


2. 
   

   I'm defining string variable within my macro. I'm aware that __func__ macro exists in C99, but my compiler, unfortunately, doesn't support this macro or any other relevant macros.

   
   


3. 
   

   How to log the values of function arguments?

   
   

I'm pretty sure that it is not a new problem and I'm not the first one who faced with it. I'm also aware about AOP thing, but the code instrumentation is not acceptable solution for my system and I haven't found any possibility to do it with my compiler.

So I'm looking for a good ideas how to implement tracing in the most elegant way.

My environment: Legacy code, C, Watcom 10.x, real-time OS