Why is kernel_sigset_t an undeclared identifier after including signal.h? - c

Question

From the signal.h manpage, the prototype(s) for rt_sigprocmask are as follows:
/* Prototype for the glibc wrapper function */
int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
/* Prototype for the underlying system call */
int rt_sigprocmask(int how, const kernel_sigset_t *set,
kernel_sigset_t *oldset, size_t sigsetsize);
Seeing as kernel_sigset_t is in the prototype for rt_sigprocmask, I would presume that the definition for this type would be included in signal.h. But I am getting the error that kernel_sigset_t is undeclared when I am trying to use it in my program.
I wrote a small simple program to demonstrate the error:
#include <stdio.h>
#include <signal.h>
int main()
{
printf("%d\n", sizeof(kernel_sigset_t));
return 0;
}
Which gives this message when I compile:
>gcc -o tmp tmp.c
tmp.c: In function ‘main’:
tmp.c:5:24: error: ‘kernel_sigset_t’ undeclared (first use in this function)
5 | printf("%d\n", sizeof(kernel_sigset_t));
| ^~~~~~~~~~~~~~~
tmp.c:5:24: note: each undeclared identifier is reported only once for each function it appears in
Why is this happening?
Am I including the wrong thing, or what?
EDIT: FURTHER INFORMATION
The reason I am asking this question is because I am making a program that traces two identical programs running in parallel, and compares the arguments of every system call to check that they are equal.
In order to do this, I need to check that system call arguments that are pointers point to the same data in both of the traced programs.
So, with the rt_sigprocmask system call, I want to check that the kernel_sigset_t pointers set and oldset both point to the same data. I would do this by comparing sizeof(kernel_sigset_t) length of data at the addresses pointed to by these pointers, and see if they're the same (using process_vm_readv).
However, as kernel_sigset_t, is seemingly not defined, I don't know how to do this. As the manpage says, the kernel's sigset_t and the userspace one are different sizes: how am I supposed to know what is the correct size to compare? If I just use sigset_t, will it be correct, if the kernel one is different?

Answer 1

As a general rule, it's not always enough to include the header file, sometimes these definitions are buried deep within #idfef hierarchies.
For example, examining the Linux doco for the sigprocmask call, you can see the required feature test macros:
_POSIX_C_SOURCE >= 1 || _XOPEN_SOURCE || _POSIX_SOURCE
meaning that one of those has to be true in order to get sigprocmask.
However, in this particular case, the manpage shows the most likely problem. In the section detailing differences between glibc (user-space) and kernel calls, we see (emphasis added):
The kernel's definition of sigset_t differs in size from that used by the C library. In this manual page, the former is referred to as kernel_sigset_t (it is nevertheless named sigset_t in the kernel sources).
In other words, it has a different name to that shown in the documented prototype and, unfortunately, the same name as the one defined in user-space.
This is likely to lead to all sorts of issues if you mix user-space and kernel methods - my advice would be to just use the user-space ones if possible, and leave the kernel ones to, well, kernel developers :-)
From a cursory investigation, the rt variant of the system call (this is not the user-space function) was added to cater for a larger signal set - once real-time signals were added, the signal bit-mask grew beyond 32 bits so the signal set had to be expanded.
The user-space function will intelligently call the correct system call under the covers, and the older system call is still there but deprecated. That function call will also silently prevent you from fiddling with the signals used by NPTL, the native POSIX threading library.
In respect to the updates to your question, in which you state you want to track system calls to ensure the arguments passed in are the same, you don't actually need to know the size of that structure.
The way rt_sigprocmask works is that the length of the structure is actually one of the arguments, sigsetsize. So that's the size you should be using for comparison.