Skip to contentSkip to conversation

what is_single_threaded() does?

DISCUSSION Oleg Nesterov 2 participants 3 messages Mar 31, 2009 – Apr 2, 2009

lore
Share & tools
lore
#0 lore raw

I found this helper by accident, and I am puzzled.

/**
* is_single_threaded - Determine if a thread group is single-threaded or not
* @p: A task in the thread group in question
*
* This returns true if the thread group to which a task belongs is single
* threaded, false if it is not.
*/

But this is not what the code does? The "t->mm == mm" check below means it also returns false if ->mm is shared with another CLONE_VM process ?

Could you explain what is right, the comment or the code?

	bool is_single_threaded(struct task_struct *p)
	{
		struct task_struct *g, *t;
		struct mm_struct *mm = p->mm;

		if (atomic_read(&p->signal->count) != 1)
			goto no;

Is this correct? Let's suppose the main thread dies, and the thread group has only one live thread. In that case signal->count == 2.

		if (atomic_read(&p->mm->mm_users) != 1) {
			read_lock(&tasklist_lock);
			do_each_thread(g, t) {

Why do_each_thread() ? for_each_process() is enough, all sub-threads use the same ->mm.

				if (t->mm == mm && t != p)
					goto no_unlock;

What about use_mm() ? Looks like this needs PF_KTHREAD check.

			} while_each_thread(g, t);
			read_unlock(&tasklist_lock);
		}

		return true;

Perhaps it should be current_is_single_thread(void) ...

Oleg.

#1 lore raw
Quoted 2 lines · Oleg Nesterov

But this is not what the code does? The "t->mm == mm" check below means it also returns false if ->mm is shared with another CLONE_VM process ?

It's a matter of defining what is meant by single-threaded, I suppose. For the purposes of security checks, that means not being part of the same group of threads and not sharing VM space.

Linux has a very fuzzy view of threads, whereby different tasks can share different sets of things. In my opinion it's excessive and unnecessary, and probably mostly unused.

Quoted 5 lines
		if (atomic_read(&p->signal->count) != 1)
			goto no;

Is this correct? Let's suppose the main thread dies, and the thread group has only one live thread. In that case signal->count == 2.

Doesn't exit() kill the subsidiary threads in such a case? I don't recall.

It appears that the zombie would retain a pointer to p->signal so that wait_task_zombie() can get stuff out of it - but can wait_task_zombie() actually access a thread group that still has active threads?

I don't think this is a real problem, at least for the two security users of it. It is still effectively multithreaded, even though one of the threads is a zombie, and indeed it would appear the process is busy imploding.

Quoted 2 lines

Why do_each_thread() ? for_each_process() is enough, all sub-threads use the same ->mm.

Firstly, that's what the original code that I extract out to this function did; secondly, it doesn't make much difference: do_each_thread() does the filtering for us that we'd have to do ourselves if we used for_each_process(); and thirdly, it is neither required nor enforced that all sub-threads use the same ->mm.

Actually, a better way of doing things may be to use a list of threads rooted on signal_struct.

Quoted 1 line

What about use_mm() ? Looks like this needs PF_KTHREAD check.

I'm not sure what you mean. Are you suggesting this should use use_mm()? Or are you suggesting that use_mm() is wrong?

Quoted 1 line

Perhaps it should be current_is_single_thread(void) ...

Perhaps.

#2 lore raw
Quoted 9 lines · David Howells
Quoted 2 lines · Oleg Nesterov

But this is not what the code does? The "t->mm == mm" check below means it also returns false if ->mm is shared with another CLONE_VM process ?

It's a matter of defining what is meant by single-threaded, I suppose. For the purposes of security checks, that means not being part of the same group of threads and not sharing VM space.

Then I think it is better to change the comment,

Quoted 2 lines

Linux has a very fuzzy view of threads, whereby different tasks can share different sets of things.

The comment says:

Determine if a thread group is single-threaded

"thread group" is what we have in ->thread_group.

Quoted 9 lines

probably mostly unused.

Quoted 5 lines
		if (atomic_read(&p->signal->count) != 1)
			goto no;

Is this correct? Let's suppose the main thread dies, and the thread group has only one live thread. In that case signal->count == 2.

Doesn't exit() kill the subsidiary threads in such a case? I don't recall.

No. Well, sys_exit() (and thus pthread_exit()) doesn't.

Quoted 2 lines

It appears that the zombie would retain a pointer to p->signal so that wait_task_zombie() can get stuff out of it -

Yes,

Quoted 2 lines

but can wait_task_zombie()
actually access a thread group that still has active threads?

Not sure I understand... But, if a thread group that still has active threads, wait_task_zombie() will not be called.

Quoted 2 lines

I don't think this is a real problem, at least for the two security users of it.

I do not claim this is security problem. But still it doesn't look right to me,

Quoted 1 line

It is still effectively multithreaded,

Why? The main thread is really dead, it has no ->mm, it can do nothing. We only have a task_struct which is not released untill all threads exit.

Quoted 5 lines
Quoted 2 lines

Why do_each_thread() ? for_each_process() is enough, all sub-threads use the same ->mm.

Firstly, that's what the original code that I extract out to this function did;

OK,

Quoted 3 lines

secondly, it doesn't make much difference: do_each_thread() does the filtering for us that we'd have to do ourselves if we used for_each_process(); and thirdly,

What do you mean? do_each_thread() iterates over all threads in system, the number of processes can be much lower. And we hold tasklist, not good.

Quoted 2 lines

it is neither required nor enforced that all sub-threads use the same ->mm.

It is required and enforced. CLONE_THREAD without CLONE_VM results in -EINVAL.

Quoted 2 lines

Actually, a better way of doing things may be to use a list of threads rooted on signal_struct.

Can't understand. We already have this list of threads: ->thread_group.

And confused. You said "and not sharing VM space" above, how this list can help?

Quoted 4 lines
Quoted 1 line

What about use_mm() ? Looks like this needs PF_KTHREAD check.

I'm not sure what you mean. Are you suggesting this should use use_mm()? Or are you suggesting that use_mm() is wrong?

The aio kernel thread can borrow ->mm from user-space process. In that case is_single_threaded() will wrongly retun false. is_single_threaded() should not check ->mm if PF_KTHREAD.

Quoted 3 lines
Quoted 1 line

Perhaps it should be current_is_single_thread(void) ...

Perhaps.

Yes, because it doesn't makes to much sense to call this helper unless p == current.

Oleg.