#define related Query - c

Question

I was doing code porting from Linux to Windows. I am using Visual Studio environment. I am stuck with one problem.
There is a function call with 2 parameters for Acquire and Release a semaphore in Windows.
The Linux code has one parameter
Windows:
KeInitializeSpinLock(spinlock,oldIRQL);
Linux
spin_lock_init(spinlock);
I have generic call like which I have to use :
Get_Lock(spinlock);
How do I do this for windows without changing the prototype of Get_Lock ?
I tried the following :
#define Get_Lock(lock) \
KIRQL oldIrql;\
KeAcquireSpinLock(&(lock),&oldIrql);
#define Release_Lock(sync) KeReleaseSpinLock(&(sync),oldIrql)
But the compiler is giving errors .. Basically I want to retain the value of oldIrql because that value is needed for KeReleaseSpinLock
Error
error C2275: 'KIRQL' : illegal use of this type as an expression
error C2146: syntax error : missing ';' before identifier 'oldIrql'
error C2065: 'oldIrql' : undeclared identifier
error C2065: 'oldIrql' : undeclared identifier
error C2065: 'oldIrql' : undeclared identifier
KIRQL is defined as
typedef UCHAR KIRQL
What wrong am I doing here ? Or Is there any other method which is there which can be used without changing the prototype of the Get_Lock and Release_Lock?

Answer 1

The problem is due to Microsoft compiler's only supporting C89 standard, which does not allow the intermingling of code and declarations. Get_Lock() is being called after a line of code (I suspect), which introduces the declaration of oldIrql.
If it is the case that the lock is obtained and released in the same scope always a possible fix (hack) would be to declare KIRQL oldIrql; at the top of the scope where Get_Lock() and Release_Lock() is called, and remove the declaration from Get_Lock().
A tidier solution would be to eliminate the macros and introduce a new struct that defines a lock. For example:
typedef struct _lock
{
#ifdef WIN32
UCHAR oldIrql;
PKSPIN_LOCK sem;
#else
#endif
} lock;
lock* lock_new()
{
lock* result = malloc(sizeof(lock));
/* Perform OS dependent initialisation. */
#ifdef WIN32
#else
#endif
return result;
}
void lock_delete(lock* aLock)
{
/* Perform OS dependent tidy tasks. */
#ifdef WIN32
#else
#endif
free(aLock);
}
void lock_obtain(lock* aLock)
{
/* OS dependent acquire. */
#ifdef WIN32
KeAcquireSpinLock(&aLock->sem, &aLock->oldIrql);
#else
#endif
}
void lock_release(lock* aLock)
{
/* OS dependent release. */
#ifdef WIN32
KeReleaseSpinLock(&aLock->sem, aLock->oldIrql);
#else
#endif
}

Answer 2

I also suspect the reason posted by hmjd. But, in my opinion, the solution can be as follows:
#define Get_Lock(lock) { KIRQL oldIrql; KeAcquireSpinLock(&(lock),&oldIrql);
#define Release_Lock(sync) KeReleaseSpinLock(&(sync),oldIrql) }
But, you need to ensure that Get_Lock & Release_Lock is in same scope which anyway you would be ensuring as per your comments.
The idea is mostly same as that of pthread_cleanup_push & pthread_cleanup_pop. You can refer to the same also.