1

Possible Duplicate:
Invalid read/write sometimes creates segmentation fault and sometimes does not

I was doing some experimentation with malloc and wrote this very small program on a linux m/c:

int main(){
    int *p=NULL;
    p = (int *)malloc(10);
    *(p + 33*1000) = 5;
    free(p);
    return 0;
   }

This program is not giving segmentation fault but if i change the line 5 to this *(p + 34*1000) = 5; Then it gives a segmentation fault. On my system the page size is 4K.

I am not able to explain why its giving a segmentation fault at around 128Kb(34*1000 is around 128K) after p.

If anyone can explain this with the perspective of memory management in linux that would be great.

Community
  • 1
  • 1
ankur
  • 74
  • 4

5 Answers5

4

You are accessing beyond the memory you allocated for p with both *(p+33*1000),*(p+34*1000) which is undefined behaviour. You can't reason out as it may "work" or crash or anything can happen.

P.P
  • 117,907
  • 20
  • 175
  • 238
  • 1
    I am deliberately accessing a memory area which i have not allocated, my question is that why it is giving segmentation fault for p + 34*1000 and not giving any error for p + 33*1000 – ankur Sep 04 '12 at 09:06
  • As I said before, you can't reason out an undefined behaviour which is not comforming to the C language standard. In the future, it may crash when you access p+33000 and *seem* to work for p+33000. – P.P Sep 04 '12 at 09:09
2

You are modifying memory that you have not allocated yourself - the address you are writing to is way beyond the limits of your array. Whenever you write beyond an array bounds you run the risk of a segfault - it depends on the memory location. It may not segfault depending on the address, but there is no way that this is a good thing to do and results will be unpredictable.

mathematician1975
  • 21,161
  • 6
  • 59
  • 101
2

This program exhibits undefined behavior (per the C standard) and, strictly speaking, there's nothing else to explain about it.

The language standard does not in any way describe how memory management is or should be implemented at the low level on any particular platform. Some memory areas can be accessible despite you not explicitly allocating them.

Alexey Frunze
  • 61,140
  • 12
  • 83
  • 180
0

After allocating space for 10 integers you can only dereference those 10 by *(p+0), *(p+1), ... ,*p(p+8) ,*p(p+9). No more else you're beyond the extents of what you've allocated.

Dereferencing elsewhere may mean you're attempting to use an invalid pointer, and hence the segmentation fault.

acraig5075
  • 10,588
  • 3
  • 31
  • 50
0

May be that's the available memory in the system. In this case all <= 33 * 1000 will pass and all >= 34 *1000 will fail.

Ramana
  • 32
  • 5