fix integer overflow in H-TCP congestion control
Subsystems (5)
PATCH 1/1 fix integer overflow in H-TCP congestion control
When using H-TCP with a single flow on a 500Mbit connection (or less actually), alpha can exceed 65000, so alpha needs to be a u32.
net/ipv4/tcp_htcp.c +1 -1
@@ -23,7 +23,7 @@ module_param(use_bandwidth_switch, int,MODULE_PARM_DESC (use_bandwidth_switch,"turn on/off bandwidth switcher" );struct htcp { -u16 alpha;/* Fixed point arith, << 7 */ +u32 alpha;/* Fixed point arith, << 7 */ u8 beta;/* Fixed point arith, << 7 */ u8 modeswitch;/* Delay modeswitch until we had at least one congestion event */ u32 last_cong;/* Time since last congestion event end */
David Miller
maintainerYour patch doesn't apply, your email client turned the tab characters in the patch into spaces.
Please fix and resubmit, thank you.
When using H-TCP with a single flow on a 500Mbit connection (or less actually), alpha can exceed 65000, so alpha needs to be a u32.
net/ipv4/tcp_htcp.c +1 -1
@@ -23,7 +23,7 @@ module_param(use_bandwidth_switch, int,MODULE_PARM_DESC (use_bandwidth_switch,"turn on/off bandwidth switcher" );struct htcp { -u16 alpha;/* Fixed point arith, << 7 */ +u32 alpha;/* Fixed point arith, << 7 */ u8 beta;/* Fixed point arith, << 7 */ u8 modeswitch;/* Delay modeswitch until we had at least one congestion event */ u32 last_cong;/* Time since last congestion event end */
From: Gavin McCullagh <[email protected]>
Date: Wed, 25 Oct 2006 09:47:26 +0100
Quoted 5 lines
When using H-TCP with a single flow on a 500Mbit connection (or less actually), alpha can exceed 65000, so alpha needs to be a u32.
Signed-off-by Gavin McCullagh <[email protected]>Signed-off-by Doug Leith <[email protected]>
Applied, thank you.
RFC PATCH 1/1 dont insert sockets/pipes dentries into dentry_hashtable.
Hi David
Here is the patch I cooked after our mail exchange. (was [RFC] Any strong reason why socket dentries are hashed in global dentry_hashtable )
If necessary, I could split this patch in 4 elementary patches. I chose to sent it as one patch for initial discussion.
[RFC, PATCH] dont insert sockets/pipes dentries into dentry_hashtable.
We currently insert sockets/pipes dentries into the global dentry hashtable. This is *useless* because there is currently no way these entries can be used for a lookup(). (/proc/xxx/fd/xxx uses a different mechanism)
Machines with a lot of sockets/pipes might suffer from longer chains in dentry hashtable.
The goals of this patch are :
[0] No more insertion in hashtable of sockets/pipes dentries.
[1] Introduction of a DENTRY_DELETED flag, that can distinguish dentries that were deleted and others in d_path(). (previous code was using d_unhashed())
[2] Small optimization to bypass RCU freeing in d_free() for dentries that were never hashed (like sockets and pipes). Such dentries dont have to wait a RCU grace period.
[3] Plug socket code to use d_instantiate() instead of d_hash() (No more need for a private d_delete function, and dentry_operations)
[4] Plug pipe code to use d_instantiate() instead of d_hash() (No more need for a private d_delete function, and dentry_operations)
Another step would be to eliminate dentries for sockets/pipes, but that's another story. (Or at least allocate them from a separate kmem_cache_t as they are not reclaimable, and they might be smaller than a full dentry)
include/linux/dcache.h +1 -0
@@ -175,6 +175,7 @@#define DCACHE_UNHASHED 0x0010#define DCACHE_INOTIFY_PARENT_WATCHED 0x0020/* Parent inode is watched */ +#define DCACHE_DELETED 0x0040/* dentry was deleted */ extern spinlock_t dcache_lock;
fs/dcache.c +14 -5
@@ -68,15 +68,19 @@ .age_limit = 45, }; -static void d_callback (struct rcu_head *head) +static void __d_free (struct dentry *dentry) { - struct dentry * dentry = container_of(head, struct dentry, d_u.d_rcu); -if (dname_external (dentry))kfree (dentry->d_name.name);kmem_cache_free (dentry_cache, dentry); } +static void d_callback (struct rcu_head *head) +{ + struct dentry * dentry = container_of(head, struct dentry, d_u.d_rcu); +__d_free (dentry); +} +/* * no dcache_lock, please. The caller must decrement dentry_stat.nr_dentry * inside dcache_lock.
@@ -85,7 +89,11 @@ {if (dentry->d_op && dentry->d_op->d_release) dentry->d_op->d_release (dentry); -call_rcu (&dentry->d_u.d_rcu, d_callback); +/* if dentry was never inserted into hash, immediate free is OK */ +if (dentry->d_hash.pprev ==NULL ) +__d_free (dentry); +else +call_rcu (&dentry->d_u.d_rcu, d_callback); }/*
@@ -1376,6 +1384,7 @@return ; } + dentry->d_flags |=DCACHE_DELETED ;if (!d_unhashed (dentry))__d_drop (dentry);
@@ -1749,7 +1758,7 @@ *--end ='\0' ; buflen--; -if (!IS_ROOT (dentry) &&d_unhashed (dentry)) { +if (!IS_ROOT (dentry) && (dentry->d_flags &DCACHE_DELETED )) { buflen -=10 ; end -=10 ;if (buflen <0 )
net/socket.c +3 -9
@@ -304,13 +304,6 @@ .kill_sb = kill_anon_super, }; -static int sockfs_delete_dentry (struct dentry *dentry) -{ -return 1 ; -} -static struct dentry_operations sockfs_dentry_operations = { - .d_delete = sockfs_delete_dentry, -};/* * Obtains the first available file descriptor and sets it up for use.
@@ -360,8 +353,9 @@if (unlikely (!file->f_dentry))return -ENOMEM ; - file->f_dentry->d_op = &sockfs_dentry_operations; -d_add (file->f_dentry,SOCK_INODE (sock)); +/* Dont insert socket dentry into global dentry hashtable */ +d_instantiate (file->f_dentry,SOCK_INODE (sock)); + file->f_vfsmnt =mntget (sock_mnt); file->f_mapping = file->f_dentry->d_inode->i_mapping;
fs/pipe.c +3 -13
@@ -828,14 +828,6 @@ }static struct vfsmount *pipe_mnt__read_mostly ; -static int pipefs_delete_dentry (struct dentry *dentry) -{ -return 1 ; -} - -static struct dentry_operations pipefs_dentry_operations = { - .d_delete = pipefs_delete_dentry, -};static struct inode *get_pipe_inode (void ) {
@@ -891,17 +883,15 @@if (!inode) goto err_file; -sprintf (name,"[%lu]" , inode->i_ino); + this.len =sprintf (name,"[%lu]" , inode->i_ino); this.name = name; - this.len =strlen (name); this.hash = inode->i_ino;/* will go */ err = -ENOMEM ; dentry =d_alloc (pipe_mnt->mnt_sb->s_root, &this);if (!dentry) goto err_inode; - - dentry->d_op = &pipefs_dentry_operations; -d_add (dentry, inode); +/* Dont insert pipe dentry into global dentry hashtable */ +d_instantiate (dentry, inode); f->f_vfsmnt =mntget (pipe_mnt); f->f_dentry = dentry; f->f_mapping = inode->i_mapping;
David Miller
maintainerRe: [RFC, PATCH] dont insert sockets/pipes dentries into dentry_hashtable.
From: Eric Dumazet <[email protected]>
Date: Tue, 31 Oct 2006 19:48:48 +0100
Quoted 4 lines
We currently insert sockets/pipes dentries into the global dentry hashtable. This is *useless* because there is currently no way these entries can be used for a
lookup(). (/proc/xxx/fd/xxxuses a different mechanism)
It turns out that while procfs uses a different "mechanism", those procfs symlinks do point to the real socket dentry, so when you readlink() on it you do d_path() on the real socket dentry.
If you unhash these things, I'm pretty sure you'll see an ugly "(deleted)" at the end of the symlink string for /proc/$pid/fd/$X files that are sockets or something like that.
Al Viro just suggested a way around this to me:
1) Just mark the dentry HASHED by hand in the dentry flags, but don't actually hash it.
2) Create a special dentry->d_deleted method for sockets that returns 0 and clears by hand the HASHED flag bit in the dentry (see what dput() does when this happens).
It's an abuse but it will work.
Re: [RFC, PATCH] dont insert sockets/pipes dentries into dentry_hashtable.
Quoted 8 lines · David Miller
From: Eric Dumazet <[email protected]>
Date: Tue, 31 Oct 2006 19:48:48 +0100Quoted 4 lines
We currently insert sockets/pipes dentries into the global dentry hashtable. This is *useless* because there is currently no way these entries can be used for a
lookup(). (/proc/xxx/fd/xxxuses a different mechanism)
Quoted 7 lines
It turns out that while procfs uses a different "mechanism", those procfs symlinks do point to the real socket dentry, so when you
readlink()on it you dod_path()on the real socket dentry.If you unhash these things, I'm pretty sure you'll see an ugly "(deleted)" at the end of the symlink string for
/proc/$pid/fd/$Xfiles that are sockets or something like that.
No no, my patch takes care of that.
You still see the right link for pipes and sockets on /proc/$pid/fd/XXX
And " (deleted)" is correctly added to deleted files.
Quoted 12 lines
Al Viro just suggested a way around this to me:
1) Just mark the dentry HASHED by hand in the dentry flags, but don't actually hash it.
2) Create a special
dentry->d_deletedmethod for sockets that returns 0 and clears by hand the HASHED flag bit in the dentry (see whatdput()does when this happens).It's an abuse but it will work.
Why hack when a proper thing can be done ?
David Miller
maintainerRe: [RFC, PATCH] dont insert sockets/pipes dentries into dentry_hashtable.
From: Eric Dumazet <[email protected]>
Date: Wed, 01 Nov 2006 09:21:06 +0100
Quoted 5 lines
No no, my patch takes care of that.
You still see the right link for pipes and sockets on
/proc/$pid/fd/XXXAnd " (deleted)" is correctly added to deleted files.
I see. Excellent :-)
Re: [RFC, PATCH] dont insert sockets/pipes dentries into dentry_hashtable.
In reply to Eric DumazetQuoted 1 line · Eric Dumazet
And " (deleted)" is correctly added to deleted files.
The hell it will.
touch a
touch b
exec 5<a
mv b a
ls -l /proc/$$/fd/5
With your patch and without it, please.
PS: getting rid of socket dentries is a bad idea with the capital "Fuck, No". For those who want to see where does that path lead and are attracted to trainwrecks in general I can recommend *BSD socket handling. They have paid quite painfully for lack of proper vnodes. It's simply not worth the resulting trouble.
Re: [RFC, PATCH] dont insert sockets/pipes dentries into dentry_hashtable.
Quoted 6 lines · Al Viro
Quoted 1 line · Eric Dumazet
And " (deleted)" is correctly added to deleted files.
The hell it will.
Quoted 7 lines
touch a
touch b
exec 5<a
mv b a
ls -l/proc/$$/fd/5With your patch and without it, please.
While we are at it,
touch a
rm a
touch a
ls -l /proc/self/fd/0 <a
With and without your patch. Note that you never remove DCACHE_DELETED after you've set it.
Re: [RFC, PATCH] dont insert sockets/pipes dentries into dentry_hashtable.
In reply to Al ViroQuoted 6 lines · Al Viro
Quoted 1 line · Eric Dumazet
And " (deleted)" is correctly added to deleted files.
The hell it will.
Quoted 7 lines
touch a
touch b
exec 5<a
mv b a
ls -l/proc/$$/fd/5With your patch and without it, please.
Yes I will do, thanks.
Quoted 6 lines
PS: getting rid of socket dentries is a bad idea with the capital "Fuck, No". For those who want to see where does that path lead and are attracted to trainwrecks in general I can recommend *BSD socket handling. They have paid quite painfully for lack of proper vnodes. It's simply not worth the resulting trouble.
I have one server with one million sockets, wasting 210 MB of ram for dentries that are only used when some guy does some /proc/$pid/fd work
Socket hot path already dont use anymore dentries, thanks to file->private_data
Eric
Re: [RFC, PATCH] dont insert sockets/pipes dentries into dentry_hashtable.
In reply to David MillerQuoted 6 lines · David Miller
It turns out that while procfs uses a different "mechanism", those procfs symlinks do point to the real socket dentry, so when you
readlink()on it you dod_path()on the real socket dentry.Al Viro just suggested a way around this to me:
Quoted 9 lines
1) Just mark the dentry HASHED by hand in the dentry flags, but don't actually hash it.
2) Create a special
dentry->d_deletedmethod for sockets that returns 0 and clears by hand the HASHED flag bit in the dentry (see whatdput()does when this happens).It's an abuse but it will work.
Thank you David and Al for the feedback.
Here is a new version of the patch with your suggestions included.
If necessary, I could split this patch in 3 elementary patches. I chose to sent it as one patch for ease of discussion.
[RFC, PATCH] dont insert sockets/pipes dentries into dentry_hashtable.
We currently insert sockets/pipes dentries into the global dentry hashtable. This is *useless* because there is currently no way these entries can be used for a lookup(). (/proc/xxx/fd/xxx uses a different mechanism)
Machines with a lot of sockets/pipes might suffer from longer chains in dentry hashtable.
Since dentries an unhashed dentry means __dpath() adds a " (deleted)", the trick for socket/pipe dentries is to :
- Right after d_alloc(), pretend they are hashed by clearing the DCACHE_UNHASHED bit. __dpath() & friends work as intended.
- Call d_instantiate() instead of d_add() : dentry is not inserted in hash table.
- Once dput() must clear the dentry, setting again DCACHE_UNHASHED bit inside the custom d_delete() function provided by socket/pipe code.
[patch 1/3] Small optimization to bypass RCU freeing in d_free() for dentries that were never hashed (like sockets and pipes). Such dentries dont have to wait a RCU grace period.
[patch 2/3] Change socket code to use d_instantiate() instead of d_add()
[patch 3/3] Change pipe code to use d_instantiate() instead of d_add()
fs/dcache.c +12 -4
@@ -68,15 +68,19 @@ .age_limit = 45, }; -static void d_callback (struct rcu_head *head) +static void __d_free (struct dentry *dentry) { - struct dentry * dentry = container_of(head, struct dentry, d_u.d_rcu); -if (dname_external (dentry))kfree (dentry->d_name.name);kmem_cache_free (dentry_cache, dentry); } +static void d_callback (struct rcu_head *head) +{ + struct dentry * dentry = container_of(head, struct dentry, d_u.d_rcu); +__d_free (dentry); +} +/* * no dcache_lock, please. The caller must decrement dentry_stat.nr_dentry * inside dcache_lock.
@@ -85,7 +89,11 @@ {if (dentry->d_op && dentry->d_op->d_release) dentry->d_op->d_release (dentry); -call_rcu (&dentry->d_u.d_rcu, d_callback); +/* if dentry was never inserted into hash, immediate free is OK */ +if (dentry->d_hash.pprev ==NULL ) +__d_free (dentry); +else +call_rcu (&dentry->d_u.d_rcu, d_callback); }/*
net/socket.c +16 -3
@@ -306,7 +306,14 @@static int sockfs_delete_dentry (struct dentry *dentry) { -return 1 ; +/* +* At creation time, we pretended this dentry was hashed +* (by clearing DCACHE_UNHASHED bit in d_flags) +* At delete time, we restore the truth : not hashed. +* (so that dput() can proceed correctly) +*/ + dentry->d_flags |=DCACHE_UNHASHED ; +return 0 ; }static struct dentry_operations sockfs_dentry_operations = { .d_delete = sockfs_delete_dentry,
@@ -354,14 +361,20 @@ this.len =sprintf (name,"[%lu]" ,SOCK_INODE (sock)->i_ino); this.name = name; - this.hash =SOCK_INODE (sock)->i_ino; + this.hash =0 ; file->f_dentry =d_alloc (sock_mnt->mnt_sb->s_root, &this);if (unlikely (!file->f_dentry))return -ENOMEM ; file->f_dentry->d_op = &sockfs_dentry_operations; -d_add (file->f_dentry,SOCK_INODE (sock)); +/* +* We dont want to push this dentry into global dentry hash table. +* We pretend dentry is already hashed, by unsetting DCACHE_UNHASHED +* This hack permits a working /proc/$pid/fd/XXX on sockets +*/ + file->f_dentry->d_flags &= ~DCACHE_UNHASHED ; +d_instantiate (file->f_dentry,SOCK_INODE (sock)); file->f_vfsmnt =mntget (sock_mnt); file->f_mapping = file->f_dentry->d_inode->i_mapping;
fs/pipe.c +17 -5
@@ -830,7 +830,14 @@static struct vfsmount *pipe_mnt__read_mostly ;static int pipefs_delete_dentry (struct dentry *dentry) { -return 1 ; +/* +* At creation time, we pretended this dentry was hashed +* (by clearing DCACHE_UNHASHED bit in d_flags) +* At delete time, we restore the truth : not hashed. +* (so that dput() can proceed correctly) +*/ + dentry->d_flags |=DCACHE_UNHASHED ; +return 0 ; }static struct dentry_operations pipefs_dentry_operations = {
@@ -891,17 +898,22 @@if (!inode) goto err_file; -sprintf (name,"[%lu]" , inode->i_ino); + this.len =sprintf (name,"[%lu]" , inode->i_ino); this.name = name; - this.len =strlen (name); - this.hash = inode->i_ino;/* will go */ + this.hash =0 ; err = -ENOMEM ; dentry =d_alloc (pipe_mnt->mnt_sb->s_root, &this);if (!dentry) goto err_inode; dentry->d_op = &pipefs_dentry_operations; -d_add (dentry, inode); +/* +* We dont want to push this dentry into global dentry hash table. +* We pretend dentry is already hashed, by unsetting DCACHE_UNHASHED +* This hack permits a working /proc/$pid/fd/XXX on pipes +*/ + dentry->d_flags &= ~DCACHE_UNHASHED ; +d_instantiate (dentry, inode); f->f_vfsmnt =mntget (pipe_mnt); f->f_dentry = dentry; f->f_mapping = inode->i_mapping;
PATCH 1/1 : avoid RCU for never hashed dentries
In reply to Eric DumazetSome dentries dont need to be globally visible in dentry hashtable. (pipes & sockets)
Such dentries dont need to wait for a RCU grace period at delete time. Being able to free them permits a better CPU cache use (hot cache)
This patch combined with (dont insert pipe dentries into dentry_hashtable) reduced time of { pipe(p); close(p[0]); close(p[1]);} on my UP machine (1.6 GHz Pentium-M) from 3.23 us to 2.86 us
(But this patch does not depend on other patches, only bench results)
fs/dcache.c +12 -4
@@ -68,15 +68,19 @@ struct dentry_stat_t dentry_stat = { .age_limit = 45, }; -static void d_callback (struct rcu_head *head) +static void __d_free (struct dentry *dentry) { - struct dentry * dentry = container_of(head, struct dentry, d_u.d_rcu); -if (dname_external (dentry))kfree (dentry->d_name.name);kmem_cache_free (dentry_cache, dentry); } +static void d_callback (struct rcu_head *head) +{ + struct dentry * dentry = container_of(head, struct dentry, d_u.d_rcu); +__d_free (dentry); +} +/* * no dcache_lock, please. The caller must decrement dentry_stat.nr_dentry * inside dcache_lock.
@@ -85,7 +89,11 @@ static void d_free(struct dentry *dentry {if (dentry->d_op && dentry->d_op->d_release) dentry->d_op->d_release (dentry); -call_rcu (&dentry->d_u.d_rcu, d_callback); +/* if dentry was never inserted into hash, immediate free is OK */ +if (dentry->d_hash.pprev ==NULL ) +__d_free (dentry); +else +call_rcu (&dentry->d_u.d_rcu, d_callback); }/*
PATCH 1/1 dont insert socket dentries into dentry_hashtable.
In reply to Eric DumazetWe currently insert socket dentries into the global dentry hashtable. This is *suboptimal* because there is currently no way these entries can be used for a lookup(). (/proc/xxx/fd/xxx uses a different mechanism). Inserting them in dentry hashtable slow dcache lookups.
To let __dpath() still work correctly (ie not adding a " (deleted)") after dentry name, we do :
- Right after d_alloc(), pretend they are hashed by clearing the DCACHE_UNHASHED bit.
- Call d_instantiate() instead of d_add() : dentry is not inserted in hash table.
__dpath() & friends work as intended during dentry lifetime.
- At dismantle time, once dput() must clear the dentry, setting again DCACHE_UNHASHED bit inside the custom d_delete() function provided by socket code, so that dput() can just kill_it.
net/socket.c +16 -3
@@ -306,7 +306,14 @@ static struct file_system_type sock_fs_tstatic int sockfs_delete_dentry (struct dentry *dentry) { -return 1 ; +/* +* At creation time, we pretended this dentry was hashed +* (by clearing DCACHE_UNHASHED bit in d_flags) +* At delete time, we restore the truth : not hashed. +* (so that dput() can proceed correctly) +*/ + dentry->d_flags |=DCACHE_UNHASHED ; +return 0 ; }static struct dentry_operations sockfs_dentry_operations = { .d_delete = sockfs_delete_dentry,
@@ -354,14 +361,20 @@ static int sock_attach_fd(struct socket this.len =sprintf (name,"[%lu]" ,SOCK_INODE (sock)->i_ino); this.name = name; - this.hash =SOCK_INODE (sock)->i_ino; + this.hash =0 ; file->f_dentry =d_alloc (sock_mnt->mnt_sb->s_root, &this);if (unlikely (!file->f_dentry))return -ENOMEM ; file->f_dentry->d_op = &sockfs_dentry_operations; -d_add (file->f_dentry,SOCK_INODE (sock)); +/* +* We dont want to push this dentry into global dentry hash table. +* We pretend dentry is already hashed, by unsetting DCACHE_UNHASHED +* This permits a working /proc/$pid/fd/XXX on sockets +*/ + file->f_dentry->d_flags &= ~DCACHE_UNHASHED ; +d_instantiate (file->f_dentry,SOCK_INODE (sock)); file->f_vfsmnt =mntget (sock_mnt); file->f_mapping = file->f_dentry->d_inode->i_mapping;
David Miller
maintainerRe: [PATCH] [NET] dont insert socket dentries into dentry_hashtable.
Andrew, I'm fine with these three patches, specifically:
[PATCH] dont insert pipe dentries into dentry_hashtable. [PATCH] [DCACHE] : avoid RCU for never hashed dentries [PATCH] [NET] dont insert socket dentries into dentry_hashtable.
Could you toss them into -mm if you haven't already? This makes better sense then me putting it into net-2.6.20 since it touches FS stuff.
Thanks!
Re: [PATCH] [NET] dont insert socket dentries into dentry_hashtable.
Quoted 8 lines · On Tue, 28 Nov 2006 15:35:31 -0800 (PST) David Miller <[email protected]>…
Andrew, I'm fine with these three patches, specifically:
[PATCH] dont insert pipe dentries into
dentry_hashtable. [PATCH] [DCACHE] : avoid RCU for never hashed dentries [PATCH] [NET] dont insert socket dentries intodentry_hashtable.Could you toss them into -mm if you haven't already?
They were in rc6-mm2.
Quoted 4 lines
This
makes better sense then me putting it into net-2.6.20 since it touches FS stuff.
No probs, they're all lined up and ready to go, thanks.