Re: [rfc] ipt_owner.c improvements

[Juha Heljoranta <juha.heljoranta@evtek.fi>]

Patrick McHardy wrote:
> Juha Heljoranta wrote:
> 
>> I'd like to make few improvements to ipt_owner.c or perhaps to create 
>> something new that is like owner match.
>>
>> First I'd like to improve performance for incoming packet matches. The 
>> next thing is to reliably identify sending/receiving process. Last 
>> proposal is to improve performance when matching is done several times 
>> per packet.
> 
> 
> As Dave Miller pointed out, the only sensible thing to do is add new
> hooks to the protocols themselves, anything else is racy. The main
> challenges are making sure incoming connections using protocols that
> support sockets aren't confirmed before they survived the socket
> hooks, with all possible module combinations, and possibly hooks for
> outgoing packets, I haven't thought about that very much.

I've been skimming through the code and concluded that the fastest and 
most reliable way to find a task receiving packet is to copy 
sock_def_readable and modify it to fit into job.

I'm not exactly sure what you mean by adding new hooks to protocols but 
I think that the this could be it (the hook for tcp and udp). Right?

I don't expect any race conditions to exist (famous last words) because 
all what we are performing is just crippled version of sock_def_readable.

As I stated before sunrpc¸ samba, bluetooth, x25, etc. reassign callback 
functions which means that things _might_ not work as expected when 
using them. Any way, I think that this is separate issue, we are not 
trying to find tasks that use samba but task that use tcp or udp, right?

To get an idea what will happen when modified version of 
sock_def_readable is issued (simplified and no locking):

void foo(struct sock *sk)
{
	if (sk->sk_sleep && waitqueue_active(sk->sk_sleep)) {
		list_for_each_safe(tmp, next,
			&sk->sk_sleep->task_list) {
			...
		}
	}
	/* for finding SIGIO targets */
	bar(sk->sk_socket->fasync_list)
}

void bar(struct fasync_struct *fa)
{
	while (fa) {
		baz(&fa->fa_file->f_owner);
		fa = fa->fa_next;
	}
}

void baz(struct fown_struct *fown)
{
	pid = fown->pid;
	if (pid > 0) {
		p = find_task_by_pid(pid);
		if (p)
			...
	} else {
		do_each_task_pid(-pid, PIDTYPE_PGID, p) {
			...
		} while_each_task_pid(-pid, PIDTYPE_PGID, p);
	}
}

There is still case of multicast to deal with (locate all receiving 
struck sock *sk and issue foo(sk) for each).

Regards,
Juha Heljoranta