Skip to contentSkip to conversation

kernel stack problem

DISCUSSION Rajat Jain 3 participants 5 messages Apr 4, 2007

lore
Share & tools
lore

Rajat Jain

author
#0 lore raw

Hi List,

Recently I got into the problem that I think relates to the small size of kernel stack. I had a function of the following form:

void func()

{
    ...
    //Block1
   {
        struct huge_var x;
        ....
        ....
    }
    ....
    //Block2
   {
        struct huge_var y;
        ....
        ....
    }
    ....
}

The above code resulted in stack overflow. I had an understanding that since the scope of variables x & y are limited to their blocks only, the space for them will be allocated and released when the block is entered and exited respectively. And hence the kernel stack will not overflow since both x and y will not occupy memory simultaneously (one instance of the variable can easily fit in the kernel stack).

I solved this problem by having a single instance of struct huge_var declared immediately at function begining and reusing it in both blocks. But my question is when (and where) are the block scope variable allocated? In my previous case, were the two variables occupying two sperate memory areas simultaneously?

Ah, I understand that I should use kernel stack sparingly ... and will do so.

Thanks,

Rajat
-
To unsubscribe from this list: send the line "unsubscribe linux-newbie" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.linux-learn.org/faqs

#1 lore raw
Quoted 26 lines

Hi List,

Recently I got into the problem that I think relates to the small size of kernel stack. I had a function of the following form:

void func()

{
     ...
     //Block1
    {
         struct huge_var x;
         ....
         ....
     }
     ....
     //Block2
    {
         struct huge_var y;
         ....
         ....
     }
     ....
}
Quoted 7 lines

The above code resulted in stack overflow. I had an understanding that since the scope of variables x & y are limited to their blocks only, the space for them will be allocated and released when the block is entered and exited respectively. And hence the kernel stack will not overflow since both x and y will not occupy memory simultaneously (one instance of the variable can easily fit in the kernel stack).

This is wrong. Although the scope is at _block_ level, all variables are allocated on the stack at _function_ level. So, when entering func() all variables within it, including x and y, are allocated.

Quoted 9 lines

I solved this problem by having a single instance of struct huge_var declared immediately at function begining and reusing it in both blocks. But my question is when (and where) are the block scope variable allocated? In my previous case, were the two variables occupying two sperate memory areas simultaneously?

Ah, I understand that I should use kernel stack sparingly ... and will do so. Thanks,

Quoted 7 lines

Rajat

--
To unsubscribe from this list: send an email with "unsubscribe kernelnewbies" to [email protected] Please read the FAQ at http://kernelnewbies.org/FAQ

-
To unsubscribe from this list: send the line "unsubscribe linux-newbie" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.linux-learn.org/faqs

#2 lore raw
Quoted 3 lines

This is wrong. Although the scope is at _block_ level, all variables are allocated on the stack at _function_ level. So, when entering func() all variables within it, including x and y, are allocated.

But this doesn't make sense. Why would the compiler not immediately optimize both variables into the same allocation? It seems obvious to me that the amount of space pushed onto the stack when the function is entered should be the maximum space needed by any combination of local variables in-scope at any time. GCC wouldn't be that stupid, would it?

--
To unsubscribe from this list: send an email with "unsubscribe kernelnewbies" to [email protected] Please read the FAQ at http://kernelnewbies.org/FAQ

#3 lore raw
Quoted 9 lines · John Anthony Kazos Jr.
Quoted 3 lines

This is wrong. Although the scope is at _block_ level, all variables are allocated on the stack at _function_ level. So, when entering func() all variables within it, including x and y, are allocated.

But this doesn't make sense. Why would the compiler not immediately optimize both variables into the same allocation? It seems obvious to me that the amount of space pushed onto the stack when the function is entered should be the maximum space needed by any combination of local variables in-scope at any time. GCC wouldn't be that stupid, would it?

Yes, I agree. But take a look...

00:19:01 framos@core2duo:~ $> more teste.c
#include <stdio.h>

int main()
{
{
int x=5;

   printf("x=%d\n",x);
   printf("addr(x)=%p\n", &x);

   {
      int y=10;
      printf("y=%d\n",y);
      printf("add(y)=%p\n", &y);

}

return 0;
}

00:19:04 framos@core2duo:~ $> ./teste
x=5
addr(x)=0xbf8b0b00
y=10
add(y)=0xbf8b0afc
00:19:06 framos@core2duo:~ $>

-
To unsubscribe from this list: send the line "unsubscribe linux-newbie" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.linux-learn.org/faqs

#4 lore raw
In reply to John Anthony Kazos Jr.
Quoted 9 lines · John Anthony Kazos Jr.
Quoted 3 lines

This is wrong. Although the scope is at _block_ level, all variables are allocated on the stack at _function_ level. So, when entering func() all variables within it, including x and y, are allocated.

But this doesn't make sense. Why would the compiler not immediately optimize both variables into the same allocation? It seems obvious to me that the amount of space pushed onto the stack when the function is entered should be the maximum space needed by any combination of local variables in-scope at any time. GCC wouldn't be that stupid, would it?

Sorry, the last message was sent before I finished. As I was saying, I agree, and it depends on the compiler optimization level:

00:21:13 framos@core2duo:~ $> more teste.c
#include <stdio.h>

int main()
{

   {
     int x=5;
     printf("x=%d\n",x);
      printf("addr(x)=%p\n", &x);

}

   {
      int y=10;
      printf("y=%d\n",y);
      printf("add(y)=%p\n", &y);

}

return 0;
}

00:21:21 framos@core2duo:~ $> gcc -o teste teste.c 00:21:24 framos@core2duo:~ $> ./teste
x=5
addr(x)=0xbffb2200
y=10
add(y)=0xbffb21fc

If you use -O2 or -O3, yes, it works as we expect:

00:22:39 framos@core2duo:~ $> gcc -O2 -o teste teste.c 00:22:46 framos@core2duo:~ $> ./teste
x=5
addr(x)=0xbfd9e7ec
y=10
add(y)=0xbfd9e7ec

Cheers!

-
To unsubscribe from this list: send the line "unsubscribe linux-newbie" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.linux-learn.org/faqs