Segmentation Fault with pointers arrays

Question

I have a Segmentation fault according to my debugger but I don't know why. Here is the code involved. Did I miss something ?

typedef struct Process Process;
struct Process {
    unsigned int m_id;
    unsigned int m_size;
    int m_startAddr;
};

    unsigned int** memory = calloc(MEMORY_SIZE, sizeof(unsigned int*));
    Process** processList = calloc(MEMORY_SIZE, sizeof(Process*));
    unsigned int itr;
    unsigned int nb_process = 0;
    int previous_process = -1;



    for(itr = 0; itr < MEMORY_SIZE; ++itr)
    {
      if(memory[itr] != NULL)
      {  
        previous_process = *memory[itr]; // works but risk of integer overflow
        processList[nb_process]->m_id = *memory[itr]; // segfault
        processList[nb_process]->m_size = 1;         
        processList[nb_process]->m_startAddr = itr;

        nb_process++;
     }

    }
 }

EDIT : I tried to make the following changes :

Process* processList = calloc(MEMORY_SIZE,sizeof(Process));
unsigned int** memory = calloc(MEMORY_SIZE, sizeof(unsigned int*));
unsigned int nb_process = 0;
int previous_process = -1;
unsigned int itr;
Process temp;


for(itr = 0; itr < MEMORY_SIZE; ++itr)
    {
        /* if memory unit is not occupied */
        if(memory[itr] != NULL)
        {
            /* if process is not known yet */
            if(*memory[itr] != previous_process)
            {
                previous_process = *memory[itr];
                printf("previous_process %u \n", previous_process);
                temp.m_id = *memory[itr];
                temp.m_size = 1;
                temp.m_startAddr = itr;

                processList[nb_process] = temp;

                nb_process++;

            }
            /* if the process is already known */
            else
            {
                printf("size %u \n", processList[nb_process].m_size);
                processList[nb_process].m_size++;
            }
        }
    }

The output of previous_process is correct. However, the output of size got a problem. First, it has always two values below what it should (14 instead of 16, 30 instead of 32; etc...) at the end of the for loop. Worse, the count start at 0, while it should start at 1, since i initialize temp.m_size with one before copying it into processList. So the copy doesn't work... Why ? Should i use memcpy ?

Don't dereference NULL? Of course, there's no requirement for NULL to be bitwise zero, so it's not even certain that calloc() will create NULL-pointers, but in practice that is probably what is happening. — user3185968
– user3185968, Commented Dec 22, 2015 at 12:52
Checking for memory[itr] != NULL is obviously insufficient. You also need to check whether processList[nb_process] != NULL. — user3185968
– user3185968, Commented Dec 22, 2015 at 13:01
@EOF I forgot to write the condition where i check if memory[itr] is null or not, my bad. For Karoly Horvath, i use ** because i want arrays of pointers. The whole program depends on if those pointers are NULL or point to something during runtime. — Csi
– Csi, Commented Dec 22, 2015 at 13:02
The reason for seg fault is *memory[itr] is not initialised. Accessing an uninitialised variable leads to undefined behavior, of which segmentation fault is one case. — haccks
– haccks, Commented Dec 22, 2015 at 13:13

John Zwinck · Accepted Answer · 2015-12-22 13:12:18Z

2

You do this:

unsigned int** memory = calloc(MEMORY_SIZE, sizeof(unsigned int*));
*memory[0]

You allocated space for an array of pointers, but then you dereference those pointers. But they are all zero (which on most systems is NULL, but in any case is not a valid pointer because it came from nowhere). That can't work.

edited Dec 22, 2015 at 13:12

answered Dec 22, 2015 at 12:54

John Zwinck

252k44 gold badges346 silver badges459 bronze badges

Sign up to request clarification or add additional context in comments.

4 Comments

user3185968 Over a year ago

You might want to clarify the part where calloc() causes NULL, because that is not required by the standard.

Csi Over a year ago

@John Zwinck I forgot to write the condition where i check if memory[itr] is null or not, my bad.

Ken Clement Over a year ago

The comments about de-referencing a NULL pointer are correct as are the comments pointing out that all zeros (the result of the calloc) in a pointer does not necessarily make it null. Even if you are using a (rare) implementation where zeros is something other than null, it is never okay to directly assign a non-address-derived value to a pointer except when using a well-defined memory location (e.g. device driver) and then you would make such a pointer volatile.

John Zwinck Over a year ago

@EOF: I have clarified that part. Pedants rejoice!

Ken Clement · Accepted Answer · 2015-12-22 13:08:17Z

1

In addition to John's answer above you are also allocating an array of pointers

Process** processList = calloc(MEMORY_SIZE, sizeof(Process*));
unsigned int nb_process = 0;

You must ensure that each of that array of pointers is initialized with something valid before de-referencing them as they are.

answered Dec 22, 2015 at 13:08

Ken Clement

7784 silver badges13 bronze badges

Collectives™ on Stack Overflow

Segmentation Fault with pointers arrays

2 Answers 2

4 Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

4 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related