Skip to contentSkip to conversation

4K stacks default, not a debug thing any more...?

RFC PATCH In review Jesper Juhl 12 participants 24 messages Jul 11, 2007 – Jul 18, 2007

lore
Share & tools
lore
#0 lore raw

RFC PATCH 1/1 4K stacks default, not a debug thing any more...?

Hi,

I'm wondering if it's time to make 4K stacks the default and to start considering removing the 8K stack option alltogether soon?

One of the big problem spots was XFS, but that got some stack usage fixes recently, and the 4K stack option has been around for quite a while now, so people really should have gotten around to fixing any
code that can't handle it. Are there still any big problem areas
remaining?

As a starting point, something like the patch below that makes 4K stacks default and make them no longer depend on DEBUG_KERNEL could be the way to go. Then after a while of this being in effect we could remove the option of a 8K stack alltogether.

What say you?

---
 arch/i386/Kconfig.debug |    2 +-
 1 files changed, 1 insertions(+), 1 deletions(-)
arch/i386/Kconfig.debug +1 -1
index b31c080..9b23bff 100644
@@ -58,7 +58,7 @@ config DEBUG_RODATA
 
 config 4KSTACKS
 	bool "Use 4Kb for kernel stacks instead of 8Kb"
-	depends on DEBUG_KERNEL
+	default y
 	help
 	  If you say Y here the kernel will use a 4Kb stacksize for the
 	  kernel stack attached to each process/thread. This facilitates
Signature · 3 lines
Jesper Juhl <[email protected]>
Don't top-post  http://www.catb.org/~esr/jargon/html/T/top-post.html
Plain text mails only, please      http://www.expita.com/nomime.html
#1 lore raw
Quoted 6 lines · Jesper Juhl

Hi,

I'm wondering if it's time to make 4K stacks the default and to start considering removing the 8K stack option alltogether soon?

One of the big problem spots was XFS, but that got some stack usage fixes recently, and the 4K stack option has been around for quite a while now, so people really should have gotten around to fixing any code that can't handle it. Are there still any big problem areas remaining?

Has anyone fixed the infrequent crashes with 4K stacks and ext3 -> LVM snapshot -> LVM -> DM mirror -> libata?

The latest (as of 150 days ago) Fedora 6 32-bit kernels crashed every week or two, the 64-bit kernel, which I believe uses 8K stacks, has been up 150 days.

#2 lore raw
Quoted 6 lines · Zan Lynx
Quoted 5 lines · Jesper Juhl

Hi,

I'm wondering if it's time to make 4K stacks the default and to start considering removing the 8K stack option alltogether soon?

Quoted 8 lines
Quoted 5 lines

One of the big problem spots was XFS, but that got some stack usage fixes recently, and the 4K stack option has been around for quite a while now, so people really should have gotten around to fixing any
code that can't handle it. Are there still any big problem areas
remaining?

Has anyone fixed the infrequent crashes with 4K stacks and ext3 -> LVM snapshot -> LVM -> DM mirror -> libata?

Ahem: ext3 -> LVM snapshot -> LVM -> DM mirror -> DM crypt -> md -> libata, or worse.

No, it's not fixed. The model is wrong. Virtual block drivers should not be callling submit_bio. The recursive IO submissions should be handled on a dedicated stack, most probably allocated as part of the request queue. This could be done easily in device mapper and md, or better, in submit_bio.

Regards,

Daniel

#3 lore raw
Quoted 16 lines · On Wednesday July 11, [email protected] wrote:
Quoted 6 lines · Zan Lynx
Quoted 5 lines · Jesper Juhl

Hi,

I'm wondering if it's time to make 4K stacks the default and to start considering removing the 8K stack option alltogether soon?

Quoted 8 lines
Quoted 5 lines

One of the big problem spots was XFS, but that got some stack usage fixes recently, and the 4K stack option has been around for quite a while now, so people really should have gotten around to fixing any
code that can't handle it. Are there still any big problem areas
remaining?

Has anyone fixed the infrequent crashes with 4K stacks and ext3 -> LVM snapshot -> LVM -> DM mirror -> libata?

Quoted 8 lines

Ahem: ext3 -> LVM snapshot -> LVM -> DM mirror -> DM crypt -> md -> libata, or worse.

No, it's not fixed. The model is wrong. Virtual block drivers should not be callling submit_bio. The recursive IO submissions should be handled on a dedicated stack, most probably allocated as part of the request queue. This could be done easily in device mapper and md, or better, in submit_bio.

Maybe you should read that latest kernel source code. Particularly generic_make_request in block/ll_rw_blk.c.
The comment preceding it read:

/*
* We only want one ->make_request_fn to be active at a time,
* else stack usage with stacked devices could be a problem.
* So use current->bio_{list,tail} to keep a list of requests
* submited by a make_request_fn function.
* current->bio_tail is also used as a flag to say if
* generic_make_request is currently active in this task or not.
* If it is NULL, then no make_request is active. If it is non-NULL,
* then a make_request is active, and new requests should be added
* at the tail
*/

NeilBrown

#4 lore raw
Quoted 6 lines · Neil Brown
Quoted 6 lines
Quoted 2 lines

Has anyone fixed the infrequent crashes with 4K stacks and ext3 -> LVM snapshot -> LVM -> DM mirror -> libata?

Ahem: ext3 -> LVM snapshot -> LVM -> DM mirror -> DM crypt -> md -> libata, or worse.

Quoted 8 lines
Quoted 5 lines

No, it's not fixed. The model is wrong. Virtual block drivers should not be callling submit_bio. The recursive IO submissions should be handled on a dedicated stack, most probably allocated as part of the request queue. This could be done easily in device mapper and md, or better, in submit_bio.

Maybe you should read that latest kernel source code. Particularly generic_make_request in block/ll_rw_blk.c.

And plus you've had that one sitting around since 2005, hats off for nailing the issue from way out. Sorry for missing the action, I was elsewhere. Niggles begin here.

I'm not sure I like the additional task_struct encumbrance when the functions themselves could sort it out, albeit with an API change affecting a gaggle of md and dm drivers.

Hopefully there are other users of the bio list fields, otherwise I would point out that a per-queue stack is less memory than two per-bio fields. I didn't go delving that far.

The pointer to the description of the barrier deadlock is not right, it points to the problem report when it really out to point to the definitive analysis and include a subject line, because list archives come and go:

[PATCH] block: always requeue !fs requests at the front
http://thread.gmane.org/gmane.linux.kernel/537473

Is there a good reason why we should not just put the whole analysis from Tejun Heo in as a comment? It is terse enough.

In other words, looks good to me :)

Regards,

Daniel

#5 lore raw
In reply to Jesper Juhl
Quoted 10 lines · Jesper Juhl

Hi,

I'm wondering if it's time to make 4K stacks the default and to start considering removing the 8K stack option alltogether soon?

One of the big problem spots was XFS, but that got some stack usage fixes recently, and the 4K stack option has been around for quite a while now, so people really should have gotten around to fixing any
code that can't handle it. Are there still any big problem areas
remaining?

Yes. NFS on top of XFS on top of DM/MD.

XFS got some fixes recently, of which the main one was to fix the regressions that gcc 4.x introduced by inlining single use functions that we'd split out of the common code to reduce stack usage. So in reality, there hasn't been a great deal of change in the status quo here.

In fact, things have probably got worse because the generic writeback code is slowly increasing it's stack usage....

Cheers,

Dave.

Signature · 3 lines
Dave Chinner
Principal Engineer
SGI Australian Software Group
#6 lore raw
In reply to Jesper Juhl
Quoted 2 lines · Jesper Juhl

I'm wondering if it's time to make 4K stacks the default and to start considering removing the 8K stack option alltogether soon?

Why? Leaving the option for 8k stacks isn't killing any kittens, AFAICS.

#7 lore raw
Quoted 6 lines · Ray Lee
Quoted 2 lines · Jesper Juhl

I'm wondering if it's time to make 4K stacks the default and to start considering removing the 8K stack option alltogether soon?

Why? Leaving the option for 8k stacks isn't killing any kittens, AFAICS.

Well, as long as 8K stacks are an option we'll never get all the code that doesn't work properly with 4K stacks fixed. We *might* get all the in-tree code fixed eventually, but there's still going to be lots of out-of-tree code that will keep depending on 8K stacks. And as long as 4K stacks are not reliable, distributions are stick with 8K for their kernels, people who build their own kernel are probably also going to stick to 8K most of the time, since that's the default. This makes the 4K stack option fairly pointless for most users.

If we consider 4K stacks broken, not used much, then we should just get rid of that option. That would remove a config choice (of which we have IMHO way too many already) and it would remove code that we then no longer need to maintain.

If, on the other hand, we consider 4K stacks to be the superior solution, then we should work to get all code fixed to be able to handle it so that it's actually something distros will start to enable so that we can eventually get rid of the 8K stack option alltogether. Making 4K stacks default and no longer a debug option is just the first step in that direction.

Signature · 3 lines
Jesper Juhl <[email protected]>
Don't top-post  http://www.catb.org/~esr/jargon/html/T/top-post.html
Plain text mails only, please      http://www.expita.com/nomime.html
#8 lore raw
Quoted 6 lines · Jesper Juhl

If, on the other hand, we consider 4K stacks to be the superior solution, then we should work to get all code fixed to be able to handle it so that it's actually something distros will start to enable so that we can eventually get rid of the 8K stack option alltogether. Making 4K stacks default and no longer a debug option is just the first step in that direction.

First step is to apply wli's patch which makes separate interrupt stacks orthogonal to the 4K stack option.

J

#9 lore raw
Quoted 11 lines · Jeremy Fitzhardinge
Quoted 6 lines · Jesper Juhl

If, on the other hand, we consider 4K stacks to be the superior solution, then we should work to get all code fixed to be able to handle it so that it's actually something distros will start to enable so that we can eventually get rid of the 8K stack option alltogether. Making 4K stacks default and no longer a debug option is just the first step in that direction.

First step is to apply wli's patch which makes separate interrupt stacks orthogonal to the 4K stack option.

Yes and no. If that will get things moving in the direction of getting rid of the stack size as a config option, then I'm all for it. But on the other hand it is my personal opinion that this is an area where we should just make up our minds as to whether we want 4K or 8K stacks and whether we want interrupt stacks or not, and then not have it configurable at all. I believe the goal is 4K stacks + interrupt stacks, so let's just aim for that and get rid of the configurability of the damn thing - make a choice, make it work, make it be that that's what we use and rid ourselves of the alternatives...

Signature · 3 lines
Jesper Juhl <[email protected]>
Don't top-post  http://www.catb.org/~esr/jargon/html/T/top-post.html
Plain text mails only, please      http://www.expita.com/nomime.html
#10 lore raw
Quoted 6 lines · Jesper Juhl

Yes and no. If that will get things moving in the direction of getting rid of the stack size as a config option, then I'm all for it. But on the other hand it is my personal opinion that this is an area where we should just make up our minds as to whether we want 4K or 8K stacks and whether we want interrupt stacks or not, and then not have it configurable at all.

Well, smaller stacks are better where possible, but there's nothing magic about 4k. Sure, its mostly enough, but there's no particular reason to believe it will be enough for everything. You could state a priori that all kernel code paths must fit into 4k of stack, but that's pretty arbitrary.

I'm tempted to post a patch making XFS depend on 8K stacks. I know is simplistic, given that it seems to be xfs+lvm which is particularly problematic, and other filesystems+lvm are also a problem. But its better than crashing.

J

#11 lore raw
Quoted 3 lines · Jeremy Fitzhardinge

Well, smaller stacks are better where possible, but there's nothing magic about 4k.

There is. It is exactly one page on x86. I cannot remember who said it when, but anything greater than a page implies some penalty.

Quoted 3 lines

Sure, its mostly enough, but there's no particular reason to believe it will be enough for everything. You could state a priori that all kernel code paths must fit into 4k of stack, but that's pretty arbitrary.

Jan

#12 lore raw
In reply to Jeremy Fitzhardinge
Quoted 10 lines · Jeremy Fitzhardinge
Quoted 6 lines · Jesper Juhl

Yes and no. If that will get things moving in the direction of getting rid of the stack size as a config option, then I'm all for it. But on the other hand it is my personal opinion that this is an area where we should just make up our minds as to whether we want 4K or 8K stacks and whether we want interrupt stacks or not, and then not have it configurable at all.

Well, smaller stacks are better where possible, but there's nothing magic about 4k.

Except offcourse it happens to also be the value of PAGE_SIZE at least on x86...

Quoted 3 lines

Sure, its mostly enough, but there's no particular reason to believe it will be enough for everything. You could state a priori that all kernel code paths must fit into 4k of stack, but that's pretty arbitrary.

As far as I'm aware, the actual reason for 4K stacks is that after the system has been up and running for some time getting "1 physically contiguous pages" becomes significantly easier than 2 which wouldn't be arbitrary.

Rene

#13 lore raw
Quoted 17 lines · Rene Herman
Quoted 11 lines · Jeremy Fitzhardinge
Quoted 6 lines · Jesper Juhl

Yes and no. If that will get things moving in the direction of getting rid of the stack size as a config option, then I'm all for it. But on the other hand it is my personal opinion that this is an area where we should just make up our minds as to whether we want 4K or 8K stacks and whether we want interrupt stacks or not, and then not have it configurable at all.

Well, smaller stacks are better where possible, but there's nothing magic about 4k.

Except offcourse it happens to also be the value of PAGE_SIZE at least on x86...

Quoted 8 lines
Quoted 3 lines

Sure, its mostly enough, but there's no particular reason to believe it will be enough for everything. You could state a priori that all kernel code paths must fit into 4k of stack, but that's pretty arbitrary.

As far as I'm aware, the actual reason for 4K stacks is that after the system has been up and running for some time getting "1 physically contiguous pages" becomes significantly easier than 2 which wouldn't be arbitrary.

If there are exactly two free pages in the system, the odds of them being buddies (ie adjacent AND properly aligned) is quite small. The available page pool has to grow quite a bit before the availability of order-1 page pairs approaches 100%.

So if we fail to allocate an 8k stack when we could have allocated a 4k stack, we're almost certainly failing significantly prematurely.

As I've pointed out before, it's fairly easy to make our stack growable with a trampoline in the troublesome paths. Something like:

int growstack(int headroom, int func, void *data)

{
	void *new_stack;
	int ret;

	if (likely(available_stack() > headroom))
		return func(data);
#ifdef CONFIG_GROWSTACK_STATS
	/* gather statistics about stack-heavy paths */
#endif
	/* warn/abort if we're recursing too deeply */

	new_stack = get_free_page();
	switch_to_new_stack(new_stack);
	ret = func(data);
	cleanup_stack(new_stack);
	return ret;
}
Signature · 1 line
Mathematics is the supreme nostalgia of our time.
#14 lore raw
Quoted 11 lines · Matt Mackall
Quoted 1 line · Rene Herman

As far as I'm aware, the actual reason for 4K stacks is that after the system has been up and running for some time getting "1 physically contiguous pages" becomes significantly easier than 2 which wouldn't be arbitrary.

If there are exactly two free pages in the system, the odds of them being buddies (ie adjacent AND properly aligned) is quite small. The available page pool has to grow quite a bit before the availability of order-1 page pairs approaches 100%.

So if we fail to allocate an 8k stack when we could have allocated a 4k stack, we're almost certainly failing significantly prematurely.

Quite. Ofcourse, saying "our stacks are 1 page" would be the by far easiest solution to that. Personally, I've been running with 4K stacks exclusively on a variety of machines for quite some time now, but I can't say I'm all too adventurous with respect to filesystems (especially) so I'm not sure how many problems remain with 4K stacks. I did recently see Andrew Morton say that problems _do_ still exist. If it's just XFS -- well, heck...

Moreover though, rather than 4K, the issue is "single page" stacks meaning a larger (soft-) pagesize would seem to fix things nicely. I've been reading about that on this list off and on for some time -- no idea where that stands though.

Quoted 11 lines

As I've pointed out before, it's fairly easy to make our stack growable with a trampoline in the troublesome paths. Something like:

int growstack(int headroom, int func, void *data)

{
	void *new_stack;
	int ret;

	if (likely(available_stack() > headroom))
		return func(data);
Quoted 11 lines
#ifdef CONFIG_GROWSTACK_STATS
	/* gather statistics about stack-heavy paths */
#endif
	/* warn/abort if we're recursing too deeply */

	new_stack = get_free_page();
	switch_to_new_stack(new_stack);
	ret = func(data);
	cleanup_stack(new_stack);
	return ret;
}

This would also need something to tell func() where its current_thread_info
is now at. Which might not be much of a problem. Can't think of much else
either but it's the kind of thing you'd _like_ to be a problem just to have an excuse to shoot down an icky notion like that...

Would you intend this just as a "make this path work until we fix it properly" kind of thing?

Rene.

#15 lore raw
Quoted 17 lines · Rene Herman
Quoted 7 lines · Matt Mackall
Quoted 4 lines · Rene Herman

As far as I'm aware, the actual reason for 4K stacks is that after the system has been up and running for some time getting "1 physically contiguous pages" becomes significantly easier than 2 which wouldn't be arbitrary.

Quoted 7 lines

If there are exactly two free pages in the system, the odds of them being buddies (ie adjacent AND properly aligned) is quite small. The available page pool has to grow quite a bit before the availability of order-1 page pairs approaches 100%.

So if we fail to allocate an 8k stack when we could have allocated a 4k stack, we're almost certainly failing significantly prematurely.

Quoted 6 lines

Quite. Ofcourse, saying "our stacks are 1 page" would be the by far easiest solution to that. Personally, I've been running with 4K stacks exclusively on a variety of machines for quite some time now, but I can't say I'm all too adventurous with respect to filesystems (especially) so I'm not sure how many problems remain with 4K stacks. I did recently see Andrew Morton say that problems _do_ still exist. If it's just XFS -- well, heck...

One long-standing problem is DM/LVM. That -may- be fixed now, but I suspect issues remain.

Quoted 23 lines
Quoted 11 lines

As I've pointed out before, it's fairly easy to make our stack growable with a trampoline in the troublesome paths. Something like:

int growstack(int headroom, int func, void *data)

{
	void *new_stack;
	int ret;

	if (likely(available_stack() > headroom))
		return func(data);
Quoted 11 lines
#ifdef CONFIG_GROWSTACK_STATS
	/* gather statistics about stack-heavy paths */
#endif
	/* warn/abort if we're recursing too deeply */

	new_stack = get_free_page();
	switch_to_new_stack(new_stack);
	ret = func(data);
	cleanup_stack(new_stack);
	return ret;
}
Quoted 2 lines

This would also need something to tell func() where its current_thread_info
is now at.

That'd be handled in the usual way by switch_to_new_stack. That is, we'd store the location of the old stack at the top of the new stack and then literally change everything to point to the new stack.

Quoted 3 lines

Which might not be much of a problem. Can't think of much else either but it's the kind of thing you'd _like_ to be a problem just to have an excuse to shoot down an icky notion like that...

It's not any ickier than explicitly calling schedule().

Quoted 2 lines

Would you intend this just as a "make this path work until we fix it properly" kind of thing?

Maybe.

Signature · 1 line
Mathematics is the supreme nostalgia of our time.
#16 lore raw
Quoted 10 lines · Matt Mackall
Quoted 7 lines · Rene Herman

Quite. Ofcourse, saying "our stacks are 1 page" would be the by far easiest solution to that. Personally, I've been running with 4K stacks exclusively on a variety of machines for quite some time now, but I can't say I'm all too adventurous with respect to filesystems (especially) so I'm not sure how many problems remain with 4K stacks. I did recently see Andrew Morton say that problems _do_ still exist. If it's just XFS -- well, heck...

Quoted 2 lines

One long-standing problem is DM/LVM. That -may- be fixed now, but I suspect issues remain.

Three cases were reported again in this thread alone yes. Problems do seem to be nicely isolated to that specific issue...

Quoted 2 lines
Quoted 2 lines
Quoted 2 lines

int growstack(int headroom, int func, void *data)
{

[ ... ]

Quoted 8 lines
Quoted 4 lines
Quoted 1 line

}

This would also need something to tell func() where its current_thread_info
is now at.

That'd be handled in the usual way by switch_to_new_stack. That is, we'd store the location of the old stack at the top of the new stack and then literally change everything to point to the new stack.

I might not understand what you're saying but I don't believe that would do.
The current thread_info _itself_ (ie, the struct itself, not a pointer) is located at esp & ~(THREAD_SIZE - 1) meaning you'd either have to copy over the struct to the new stack, or forego that historic optimization (don't get me wrong, either may be okay).

Quoted 3 lines
Quoted 1 line

Which might not be much of a problem. Can't think of much else either but it's the kind of thing you'd _like_ to be a problem just to have an excuse to shoot down an icky notion like that...

It's not any ickier than explicitly calling schedule().

Somewhat comparable in notion perhaps, but I disagree on the relative level of ickyness. Calling schedule() you do when you know you no longer have to hog te CPU and when you know it's safe to do so. Calling via growstack() looks to be a "ah, heck, let's err on the safe side since we don't have a bleedin' clue otherwise" sort of thing.

Quoted 3 lines
Quoted 1 line

Would you intend this just as a "make this path work until we fix it properly" kind of thing?

Maybe.

If you know, _can_ MD/LVM (and/or XFS) in fact be sanely/timely fixed, or is this looking at something fundamental?

Rene.

#17 lore raw
In reply to Matt Mackall
Quoted 9 lines · Matt Mackall
Quoted 1 line

As far as I'm aware, the actual reason for 4K stacks is that after the system has been up and running for some time getting "1 physically contiguous pages" becomes significantly easier than 2 which wouldn't be arbitrary.

If there are exactly two free pages in the system, the odds of them being buddies (ie adjacent AND properly aligned) is quite small. The available page pool has to grow quite a bit before the availability of order-1 page pairs approaches 100%.

So if we fail to allocate an 8k stack when we could have allocated a 4k stack, we're almost certainly failing significantly prematurely.

Why do the two pages have to be physically contiguous? The stack just needs to be two contiguous pages in virtual memory, but they can map to any two pages anywhere in physical memory.

#18 lore raw
Quoted 3 lines

Why do the two pages have to be physically contiguous? The stack just needs to be two contiguous pages in virtual memory, but they can map to any two pages anywhere in physical memory.

Historically we allowed DMA off the stack on old x86 systems. Removing that while a good idea would take a lot of auditing. We also have a very limited vmalloc window for mapped pages and filling that with stacks would be bad.

#19 lore raw
Quoted 6 lines · Alan Cox
Quoted 1 line

Why do the two pages have to be physically contiguous? The stack just needs to be two contiguous pages in virtual memory, but they can map to any two pages anywhere in physical memory.

Historically we allowed DMA off the stack on old x86 systems. Removing that while a good idea would take a lot of auditing. We also have a very limited vmalloc window for mapped pages and filling that with stacks would be bad.

Wow, DMA off the stack? That's just crazy.

#20 lore raw
In reply to Phillip Susi
Quoted 1 line · Phillip Susi

Why do the two pages have to be physically contiguous? The stack just needs to be two contiguous pages in virtual memory, but they can map to any two pages anywhere in physical memory.

As far as I'm aware that's just a consequence of the way linux does memory management. If we ignore highmem, virtual memory is simply +/- PAGE_OFFSET away from physical so allocating virtually contiguous pages that are _not_ physically contiguous requires mapping them somewhere (the vmalloc area) which is limited. Given that large number of threads _are_ the problem you wouldn't solve things -- you'd again be out of space, although now for a different reason.

Rene.

#21 lore raw
In reply to Jesper Juhl
Quoted 12 lines · Jesper Juhl
Quoted 11 lines · Jeremy Fitzhardinge
Quoted 6 lines · Jesper Juhl

If, on the other hand, we consider 4K stacks to be the superior solution, then we should work to get all code fixed to be able to handle it so that it's actually something distros will start to enable so that we can eventually get rid of the 8K stack option alltogether. Making 4K stacks default and no longer a debug option is just the first step in that direction.

First step is to apply wli's patch which makes separate interrupt stacks orthogonal to the 4K stack option.

Quoted 9 lines

Yes and no. If that will get things moving in the direction of getting rid of the stack size as a config option, then I'm all for it. But on the other hand it is my personal opinion that this is an area where we should just make up our minds as to whether we want 4K or 8K stacks and whether we want interrupt stacks or not, and then not have it configurable at all. I believe the goal is 4K stacks + interrupt stacks, so let's just aim for that and get rid of the configurability of the damn thing - make a choice, make it work, make it be that that's what we use and rid ourselves of the alternatives...

There are two downsides to interrupt stacks:

- an extra 4k/8k used per CPU
- stack switch time

Both of those are pretty minimal. And I'd be surprised if the latter was measurable.

Signature · 1 line
Mathematics is the supreme nostalgia of our time.
#22 lore raw
In reply to Jesper Juhl
Quoted 2 lines · Jesper Juhl

One of the big problem spots was XFS, but that got some stack usage fixes recently, and the 4K stack option has been around for quite a while now, so people really should have gotten around to fixing any code that can't handle it. Are there still any big problem areas remaining?

I get frequent crashes when I use 4k stacks with XFS+lvm, using recent kernels. When did XFS stack use reductions go in?

J

#23 lore raw
Quoted 10 lines · Jeremy Fitzhardinge
Quoted 6 lines · Jesper Juhl

One of the big problem spots was XFS, but that got some stack usage fixes recently, and the 4K stack option has been around for quite a while now, so people really should have gotten around to fixing any
code that can't handle it. Are there still any big problem areas
remaining?

I get frequent crashes when I use 4k stacks with XFS+lvm, using recent kernels. When did XFS stack use reductions go in?

February. They were fixes for gcc4.x stack usage regressions (i.e. a ~25% increase) over gcc 3.3.5. They were not new stack reduction patches....

Cheers,

Dave.

Signature · 3 lines
Dave Chinner
Principal Engineer
SGI Australian Software Group