如何检查从哪个文件调用此函数？

Question

see i have one library which has two api lets call

api1() 

and

 api2()

Now internally api2 calls api1 also.

so in one situation i want to do is that

• when some other application is calling api1() then do some special work
• but when api2() calls api1() then do'nt do that special work.

how can i do that ?

Is there any way so i can know that api1() is calling from library itself not application?

Edit :

api1()
{
sem_wait();  // this create deadlock 

// do some task 

sem_post();
}

now api2() is like this

  api2()
{
sem_wait();

api1();

sem_post();

}

see my both function...when application calls api1() i need to be work in sem_wait and sem_post but when api2() calls api1() then i dont want to sem_wait again because its make dead locks ...

i need some mechanism so api1() checks if it is being called from api2() then dont use sem_wait and sem_post

Answer 1

That's not easy to achieve by introspection. You could investigate the call stack but that is very non-portable and really not to be recommended.

One way to deal with this is to pass a parameter to control the variation of behaviour. This has the addition benefit of making the function's behaviour more transparent and explicit. As @blueshift points out, this can place a burden on external callers. Splitting the function into two versions, one for internal use and one for external use relieves that burden.

---

In light of your edit, I think the design is a little off. The synchronization responsibility should either be internal to the function, or external. It's very risky to make that responsibility sometimes be internal and sometimes be external. That would be one way round the problem. Another way around it would be to use recursive locks.

Answer 2

You'll need two different function calls (function name or parameter) for the two different jobs (+special work and -special work). Context-sensitive functions are not only not supported by C, but absolutely and totally evil because they add a whole Chomsky of complexity.

Answer 3

Often done something like this:

// internal function
static int api1_internal(void) {
  do stuff assuming the lock is held;
}

// function for external callers, doing extra locking
int api1(void) {
  int ret;
  lock();
  ret = api1_internal();
  unlock();
  return ret;
}

// some internal function using internal api1
void internalfunc(void) {
  lock();
  do some things();
  api1_internal();
  unlock();
}

Note api1_internal is declared static to stop anything outside that file using it.

If you really want to confuse yourself you could put the definition of api1() first, then have something like

#define api1 api1_internal

Which would keep your code pretty, but just confuse you later. Don't do that.

It's common to use a leading underscore for internal, non-locking versions of functions, so

static int _api1(void)

Answer 4

You can build your library so that api2() tells api1() that it is the caller. When called from outside, api1() sees an unknown caller.