Re: anon unions are cool

[Albert Cahalan <acahalan@gmail.com>]

On 1/23/06, Eric W. Biederman <ebiederm@xmission.com> wrote:
> Albert Cahalan <acahalan@gmail.com> writes:
>
> > This case is rather interesting. At more than one place I've worked,
> > I found people assuming that the kernel's "pid" was a pid, when in
> > fact it is a tid. (a "task ID" or "thread ID") The confusion probably
> > leads to kernel bugs. I've seen many bugs related to this, though I
> > can't be 100% sure that they don't all involve code that existed prior
> > to the tgid concept.
>
> Actually this is a really weird area.  A lot of it depends on your
> perspective.  current->pid is more than just a thread group ID.

It's not a thread group ID at all. It's a task ID or thread ID.

The thread group ID is something different. It's the same as
a POSIX process ID. The kernel uses "tgid" as the name.

At least you're not alone in your confusion. :-)

> You can always use kill to send a signal to the ``pid'' of any
> task.  However if that task is part of a thread group the signal
> might go to one of that threads siblings.

This is sort of a bug really, though we're probably stuck
with it now. You should get errno=ESRCH when you use
an ID that does not match up with a tgid.

The "feature" doesn't work for thread group leaders
because kill() doesn't let you specify that you really
want to address the task rather than the task group.
We have tkill() and tgkill() to address this problem.

> If you were to follow the normal rules and send to a signal
> to a thread group.  All threads would get it.  Although I
> don't think the kernel has code for that.

That would be wrong for most signals. The kernel follows
the POSIX behavior, with "process" being struct signal or
the tgid. A few signals, like SIGKILL, go the the whole process.
All others are delivered to the first task willing to take it,
which is how POSIX treats a process with threads. (there
is also different behavior for per-task stuff like SIGSEGV)

> So from a signal perspective current->pid is the pid.

Aside from bugs, no.

> However get_pid has been modified to return the thread group id.
> Instead of the PID.  And a lot of times when you are exporting
> information to user space you want the thread group id.
>
> But in practice neither thread ID nor process ID map directly
> to the kernels concept.

They sure do, unless you play with abnormal clone() flags.

> Then there is the other weird side where only the leaders of
> thread groups are placed in sessions and process groups.

That's not at all weird. It fits perfectly with the use of the tgid
as the POSIX PID and the use of the "pid" (ugh) as the POSIX
thread ID.

Aside from POSIX just being arguably weird, the only weird
things here are:

1. kill() not returning errno=ESRCH when it should
2. the name "pid" being used oddly in the kernel