External Functions and Parameter Size Limitation (C)

I am very much stuck in the following issue. Any help is very much appreciated!

Basically I have a program wich contains an array of structs and I am getting a segmentation error when I call an external function. The error only happens when I have more than 170 items on the array being passed.

Nothing on the function is processed. The program stops exactly when accessing the function.

Is there a limit for the size of the parameters that are passed to external functions?

Main.c

struct ratingObj {
    int uid;
    int mid;
    double rating;
};

void  *FunctionLib;     /*  Handle to shared lib file   */
void (*Function)();     /*  Pointer to loaded routine   */
const char *dlError;        /*  Pointer to error string */

int main( int argc, char * argv[]){
// ... some code ...
    asprintf(&query, "select mid, rating "
                     "from %s "
                     "where uid=%d "
                     "order by rand()", itable, uid);
    if (mysql_query(conn2, query)) {
        fprintf(stderr, "%s\n", mysql_error(conn2));
        exit(1);
    }
    res2 = mysql_store_result(conn2);
    int movieCount = mysql_num_rows(res2);
    // withhold is 开发者_如何学Goa variable that defines a percentage of the entries 
    // to be used for calculations (generally 20%)
    int listSize = round((movieCount * ((double)withhold/100)));
    struct ratingObj moviesToRate[listSize];
    int mvCount = 0;
    int count =0;
    while ((row2 = mysql_fetch_row(res2)) != NULL){
        if(count<(movieCount-listSize)){
            // adds to another table
        }else{
            moviesToRate[mvCount].uid = uid;
            moviesToRate[mvCount].mid = atoi(row2[0]);
            moviesToRate[mvCount].rating = 0.0;

            mvCount++;
        }
        count++;
    }
    // ... more code ...
    FunctionLib = dlopen("library.so", RTLD_LAZY);
    dlError = dlerror();
    if( dlError ) exit(1);
    Function = dlsym( FunctionLib, "getResults");
    dlError = dlerror();
    (*Function)( moviesToRate, listSize );
// .. more code
}

library.c

struct ratingObj {
    int uid;
    int mid;
    double rating;
};

typedef struct ratingObj ratingObj;

void getResults(struct ratingObj *moviesToRate, int listSize);

void getResults(struct ratingObj *moviesToRate, int listSize){
// ... more code
}

You are likely blowing up the stack. Move the array to outside of the function, i.e. from auto to static land.

Another option is that the // ... more code - array gets populated... part is corrupting the stack.

Edit 0:

After you posted more code - you are using C99 variable sized array on the stack - Bad IdeaTM. Think what happens when your data set grows to thousands, or millions, of records. Switch to dynamic memory allocation, see malloc(3).

You don't show us what listsize is, but I suppose it is a variable and not a constant.

What you are using are variable length arrays, VLA. These are a bit dangerous if they are too large since they usually allocated on the stack.

To work around that you can allocate such a beast dynamically

struct ratingObj (*movies)[listSize] = malloc(sizeof(*movies));
// ...
free(movies);

You'd then have in mind though that movies then is a pointer to array, so you have to reference with one * more than before.

Another, more classical C version would be

struct ratingObj * movies = malloc(sizeof(*movies)*listsize);
// ...
free(movies);