net: make /proc/net/protocols namespace aware

PATCH Applied Eric Dumazet 3 participants 5 messages Nov 17, 2008 – Nov 19, 2008

Subsystems (4)

Networking Network drivers Sockets Networking unix sockets

lore

Share & tools

lore

Eric Dumazet

author

2008-11-17 10:50 UTC #0 lore raw

PATCH 1/1 net: make /proc/net/protocols namespace aware

Converting /proc/net/protocols to be namespace aware is quite easy and permits us to use sock_prot_inuse_get().

This provides seperate counters for each protocol. For example we can really count TCPv6 sockets and TCPv4 sockets, while previously, we had the same value, and this value was not namespace aware.

Signed-off-by Eric Dumazet <[email protected]>

---
net/core/sock.c | 27 +++++++++++++++++++++++----

1 files changed, 23 insertions(+), 4 deletions(-)

net/unix/af_unix.c +4 -0

index a1eb596..36856ca 100644
@@ -361,6 +361,7 @@ static void unix_sock_destructor(struct sock *sk)
 		unix_release_addr(u->addr);
 
 	atomic_dec(&unix_nr_socks);
+	sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
 #ifdef UNIX_REFCNT_DEBUG
 	printk(KERN_DEBUG "UNIX %p is destroyed, %d are still alive.\n", sk,
 		atomic_read(&unix_nr_socks));

@@ -612,6 +613,9 @@ static struct sock *unix_create1(struct net *net, struct socket *sock)
 out:
 	if (sk == NULL)
 		atomic_dec(&unix_nr_socks);
+	else
+		sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);
+		
 	return sk;
 }

Eric Dumazet

author

2008-11-17 10:53 UTC #1 lore raw

Quoted 12 lines · Eric Dumazet

Converting /proc/net/protocols to be namespace aware is quite easy and permits us to use sock_prot_inuse_get().
This provides seperate counters for each protocol. For example we can really count TCPv6 sockets and TCPv4 sockets, while previously, we had the same value, and this value was not namespace aware.
Signed-off-by Eric Dumazet <[email protected]>
---
net/core/sock.c | 27 +++++++++++++++++++++++----
1 files changed, 23 insertions(+), 4 deletions(-)

Oops wrong attached file... sorry

[PATCH] net: make /proc/net/protocols namespace aware

Converting /proc/net/protocols to be namespace aware is quite easy and permits us to use sock_prot_inuse_get().

This provides seperate counters for each protocol. For example we can really count TCPv6 sockets and TCPv4 sockets, while previously, we had the same value, and this value was not namespace aware.

Signed-off-by Eric Dumazet <[email protected]>

---
net/core/sock.c | 27 +++++++++++++++++++++++----

1 files changed, 23 insertions(+), 4 deletions(-)

net/core/sock.c +23 -4

index 38de9c3..566eb82 100644
@@ -2176,7 +2176,7 @@ static void proto_seq_printf(struct seq_file *seq, struct proto *proto)
 			"%2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c\n",
 		   proto->name,
 		   proto->obj_size,
-		   proto->sockets_allocated != NULL ? atomic_read(proto->sockets_allocated) : -1,
+		   sock_prot_inuse_get(seq_file_net(seq), proto),
 		   proto->memory_allocated != NULL ? atomic_read(proto->memory_allocated) : -1,
 		   proto->memory_pressure != NULL ? *proto->memory_pressure ? "yes" : "no" : "NI",
 		   proto->max_header,

@@ -2230,7 +2230,8 @@ static const struct seq_operations proto_seq_ops = {
 
 static int proto_seq_open(struct inode *inode, struct file *file)
 {
-	return seq_open(file, &proto_seq_ops);
+	return seq_open_net(inode, file, &proto_seq_ops,
+			    sizeof(struct seq_net_private));
 }
 
 static const struct file_operations proto_seq_fops = {

@@ -2241,10 +2242,28 @@ static const struct file_operations proto_seq_fops = {
 	.release	= seq_release,
 };
 
+static __net_init int proto_init_net(struct net *net)
+{
+	if (!proc_net_fops_create(net, "protocols", S_IRUGO, &proto_seq_fops))
+		return -ENOMEM;
+
+	return 0;
+}
+
+static __net_exit void proto_exit_net(struct net *net)
+{
+	proc_net_remove(net, "protocols");
+}
+
+
+static __net_initdata struct pernet_operations proto_net_ops = {
+	.init = proto_init_net,
+	.exit = proto_exit_net,
+};
+
 static int __init proto_init(void)
 {
-	/* register /proc/net/protocols */
-	return proc_net_fops_create(&init_net, "protocols", S_IRUGO, &proto_seq_fops) == NULL ? -ENOBUFS : 0;
+	return register_pernet_subsys(&proto_net_ops);
 }
 
 subsys_initcall(proto_init);

Alexey Dobriyan

2008-11-17 11:11 UTC #2 lore raw

net/core/sock.c static const struct seq_operations proto_seq_ops = { · line 2234

Quoted 10 lines · Eric Dumazet

net/core/sock.c +2 -1

@@ -2230,7 +2230,8 @@ static const struct seq_operations proto_seq_ops = {
 
 static int proto_seq_open(struct inode *inode, struct file *file)
 {
-	return seq_open(file, &proto_seq_ops);
+	return seq_open_net(inode, file, &proto_seq_ops,
+			    sizeof(struct seq_net_private));

You have to hook seq_release_net if you do this.

net/core/sock.c static const struct file_operations proto_seq_fops = { · line 2242

Quoted 5 lines

net/core/sock.c +0 -0

 }
 
 static const struct file_operations proto_seq_fops = {

@@ -2241,10 +2242,28 @@ static const struct file_operations proto_seq_fops = {
 	.release	= seq_release,

+.release = seq_release_net,

Eric Dumazet

author

2008-11-17 11:27 UTC #3 lore raw

Quoted 14 lines · Alexey Dobriyan

net/core/sock.c static const struct seq_operations proto_seq_ops = { · line 2234
Quoted 10 lines · Eric Dumazet
net/core/sock.c +2 -1
@@ -2230,7 +2230,8 @@ static const struct seq_operations proto_seq_ops = {
 
 static int proto_seq_open(struct inode *inode, struct file *file)
 {
-	return seq_open(file, &proto_seq_ops);
+	return seq_open_net(inode, file, &proto_seq_ops,
+			    sizeof(struct seq_net_private));
You have to hook seq_release_net if you do this.

Quoted 8 lines

net/core/sock.c static const struct file_operations proto_seq_fops = { · line 2242
Quoted 5 lines
net/core/sock.c +0 -0
 }
 
 static const struct file_operations proto_seq_fops = {
@@ -2241,10 +2242,28 @@ static const struct file_operations proto_seq_fops = {
 	.release	= seq_release,
+.release = seq_release_net,

Good catch, thanks Alexey

[PATCH] net: make /proc/net/protocols namespace aware Converting /proc/net/protocols to be namespace aware is quite easy and permits us to use sock_prot_inuse_get().

This provides seperate counters for each protocol. For example we can really count TCPv6 sockets and TCPv4 sockets, while previously, we had the same value, and this value was not namespace aware.

Signed-off-by Eric Dumazet <[email protected]>

Signed-off-by Alexey Dobriyan <[email protected]>

---
net/core/sock.c | 29 ++++++++++++++++++++++++-----

1 files changed, 24 insertions(+), 5 deletions(-)

net/core/sock.c +24 -5

index 38de9c3..244d8fb 100644
@@ -2176,7 +2176,7 @@ static void proto_seq_printf(struct seq_file *seq, struct proto *proto)
 			"%2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c\n",
 		   proto->name,
 		   proto->obj_size,
-		   proto->sockets_allocated != NULL ? atomic_read(proto->sockets_allocated) : -1,
+		   sock_prot_inuse_get(seq_file_net(seq), proto),
 		   proto->memory_allocated != NULL ? atomic_read(proto->memory_allocated) : -1,
 		   proto->memory_pressure != NULL ? *proto->memory_pressure ? "yes" : "no" : "NI",
 		   proto->max_header,

@@ -2230,7 +2230,8 @@ static const struct seq_operations proto_seq_ops = {
 
 static int proto_seq_open(struct inode *inode, struct file *file)
 {
-	return seq_open(file, &proto_seq_ops);
+	return seq_open_net(inode, file, &proto_seq_ops,
+			    sizeof(struct seq_net_private));
 }
 
 static const struct file_operations proto_seq_fops = {

@@ -2238,13 +2239,31 @@ static const struct file_operations proto_seq_fops = {
 	.open		= proto_seq_open,
 	.read		= seq_read,
 	.llseek		= seq_lseek,
-	.release	= seq_release,
+	.release	= seq_release_net,
+};
+
+static __net_init int proto_init_net(struct net *net)
+{
+	if (!proc_net_fops_create(net, "protocols", S_IRUGO, &proto_seq_fops))
+		return -ENOMEM;
+
+	return 0;
+}
+
+static __net_exit void proto_exit_net(struct net *net)
+{
+	proc_net_remove(net, "protocols");
+}
+
+
+static __net_initdata struct pernet_operations proto_net_ops = {
+	.init = proto_init_net,
+	.exit = proto_exit_net,
 };
 
 static int __init proto_init(void)
 {
-	/* register /proc/net/protocols */
-	return proc_net_fops_create(&init_net, "protocols", S_IRUGO, &proto_seq_fops) == NULL ? -ENOBUFS : 0;
+	return register_pernet_subsys(&proto_net_ops);
 }
 
 subsys_initcall(proto_init);

David Miller

maintainer Applied

2008-11-19 23:14 UTC #4 lore raw

From: Eric Dumazet <[email protected]>
Date: Mon, 17 Nov 2008 12:27:23 +0100

Quoted 6 lines

Good catch, thanks Alexey
[PATCH] net: make /proc/net/protocols namespace aware Converting /proc/net/protocols to be namespace aware is quite easy and permits us to use sock_prot_inuse_get().

Quoted 6 lines

This provides seperate counters for each protocol. For example we can really count TCPv6 sockets and TCPv4 sockets, while previously, we had the same value, and this value was not namespace aware.
Signed-off-by Eric Dumazet <[email protected]>
Signed-off-by Alexey Dobriyan <[email protected]>

Applied to net-next-2.6, thanks.