Segfault when using a pointer inside a struct (Maybe related to LAPACKE) in C

Question

Since it is my first post here I hope I won't make too much mistakes ...

I am facing the following problem. When I run this piece of code (Rather long I am sorry) I got a segmentation fault in the "solve" function during the LAPACKE call.

The problem is when I don't try to open the file "dataf" in main function, this code runs without any (visible) problem.

I suppose I messed up with my type Bob and the pointers but I would like to have your point of view.

Best regards

Thibaut

#include <stdio.h>
#include <stdlib.h>
#include <lapacke/lapacke.h>

typedef struct{
   double *data;
   double *tmp;
   double **A;
   int size;
 } Bob;

void allocate(Bob *b);
void init_data(Bob *b);
void init_A(Bob* b);

void allocate(Bob *b){
   b->data = malloc(b->size*sizeof(double));
   b->tmp = malloc(b->size*sizeof(double));
   b->A = malloc(4*sizeof(double*));
   b->A[0] = malloc(b->size*sizeof(double));
   b->A[1] = malloc(b->size*sizeof(double));
   b->A[2] = malloc(b->size*sizeof(double));
   b->A[3] = malloc(b->size*sizeof(double));
}

void init_data(Bob *b){
   int i;
   for (i=0;i<b->size;i++){
      b->data[i] = 0.0;
   }
}

void init_A(Bob* b){
   int i;
   double *diag = b->A[0];
   double *down = b->A[1];
   double *up = b->A[2];
   double *up2 = b->A[3];

   for (i=0;i<b->size;i++){
     diag[i] = 2.0;
     down[i] = -1.0;
     up[i] = -1.0;
     up2[i] = 0.0;
   }
}

void solve(Bob *b){
   lapack_int info;
   lapack_int *ipiv = malloc(b->size*(sizeof(lapack_int)));
   lapack_int lsize = b->size;
   lapack_int lone = 1;

   int i;
   for (i=0;i<b->size;i++){
      b->tmp[i] = b->data[i];
   }

   info = LAPACKE_dgttrs(LAPACK_COL_MAJOR,'N',
     lsize,lone,\
     b->A[1],b->A[0],b->A[2],b->A[3],\
     ipiv, b->tmp, lsize);

   printf("%d\n",info);
   free(ipiv);
 }

int main(void){
   Bob b;
   b.size = 10000;
   allocate(&b);
   init_A(&b);
   init_data(&b);
// No Segfault if dataf is not opened
   FILE *dataf;
   dataf = fopen("data","w");
   fclose(dataf);
   solve(&b);

   free(b.data);
   free(b.tmp);
   free(b.A[0]);
   free(b.A[1]);
   free(b.A[2]);
   free(b.A[3]);
   free(b.A);
   return 0;
}

With Makefile:

P=mini
CC=gcc

CFLAGS=-g -Wall
LFLAGS=-lm -llapacke -llapack -lblas

FILES=min.c

all: $(FILES)
   $(CC) $(CFLAGS) $(LFLAGS) $(FILES) -o $(P)

EDIT: I made a mistake in my original post. The allocations of A[0] -> A[3] are doubles and not pointers to doubles.

Changing the position of fclose after solve seems to solve the problem. But in my real code it doesn't change anything ...

EDIT2: The problem was related to the LAPACK function it seems. I changed this function (to something better suited for my problem) And the memory problems are gone now.

It is not a solution to my original problem but I solved it in a certain way. Thanks for all the replies and comments that are very useful anyway :)

EDIT3: I found the origin of the problem. It is related to LAPACK. In function solve, I am allocating space for ipiv. But LAPACKE_dgttrs takes as input the ipiv that is given by the function LAPACKE_dgttrf in init_A.

So I have allocated a pointer for ipiv in my struct and I use it in the rest of the program.

Answer 1

The error is due to the fclose function, before fclose check whether dataf is NULL Or noy

FILE *dataf;
dataf = fopen("data","w"); //If file is not opened for writing, the dataf is NULL
fclose(dataf);   
solve(&b);

Change to

FILE *dataf;
dataf = fopen("data","w");

if(dataf != NULL)
    fclose(dataf);
solve(&b);

Answer 2

In your definition of "Bob", member A is defined as a pointer to a pointer, and based on your code, I'm assuming you're setting up a 2-dimensional array of doubles. If that's the case, the four statements allocating a b->A[i] should be allocating doubles, and not pointers-to-doubles.

void allocate(Bob *b){
   b->data = malloc(b->size*sizeof(double));
   b->tmp = malloc(b->size*sizeof(double));
   b->A = malloc(4*sizeof(double*));
   b->A[0] = malloc(b->size*sizeof(double));
   b->A[1] = malloc(b->size*sizeof(double));
   b->A[2] = malloc(b->size*sizeof(double));
   b->A[3] = malloc(b->size*sizeof(double));
}