检索sizeof（buff）时c程序崩溃

Question

I am creating a program in C that splits a large text file into 10 segments, and then creates 10 threads with each thread generating a word count for each segment. I took the function word_count from this code: https://github.com/prateek-khatri/seaOfC/blob/master/frequencyMultiThread.c . That program works fine for me, but when I tried to use word_count in my own program, it crashes when trying to get the size of the buffer.

It seems like everything is ok in the function getCurrentSegmentWordcount , but when that function calls word_count , it crashes (segmentation fault) at the line printf("sizeof Buff: %d", sizeof(buff)); .

#define _GNU_SOURCE
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <unistd.h>
#define NUMBER_OF_THREADS 10

//struct taken from reference:
struct return_val{
    char wordlist[100][100]; //[chars][lines]
    int count[100];
} *arr; //array of words

void *print_hello_world(void * tid)
{
    //This function prints the thread’s identifier and then exits.
    printf("Hello World. Greetings from thread %d\n", tid);
    pthread_exit(NULL);
}

void *word_count(void* num)
{ 

    int *ln = num;
    unsigned int line_number = *ln;
    //line_number++;

    printf("Thread %d\n",line_number);

    char cmd_p1[9] = "sed -n '\0";
    char cmd_p2[2];
    sprintf(cmd_p2,"%d",line_number); //stores string in buffer
    char cmd_p3[21] = "p' 'maintainers.txt'\0";
    char command[100];
    command[0] = '\0';

    //char * strcat ( char * destination, const char * source );
    //appends a copy of source to destination
    strcat(command,cmd_p1);
    strcat(command,cmd_p2);
    strcat(command,cmd_p3);
    usleep(line_number);

    char cmd[100] = " | tr [:space:] '\\n' | grep -v '^\\s*$' | sort | uniq -c | sort\0";
    strcat(command,cmd);
    printf("Command: %s\n",command);
    //fflush(stdout);



    FILE *in;
    in= popen(command, "r"); //read command and pipe into the shell
    rewind(in); //set file position to beginning of 'in'
    char buff[50];
    int counter = 0;


    //char * fgets ( char * str, int num, FILE * stream );
    //reads chars from stream and stores them as string into buff until all of buffer has been read
    printf("before\n");
    bool testBool = fgets(buff,sizeof(buff),in);
    printf("testBool: %d\n", testBool);


    //CRASH HAPPENS HERE:
    //buff 
    printf("sizeof Buff: %d", sizeof(buff));


    while(fgets(buff,sizeof(buff),in))
    {
        printf("fire 0.5");
        char c=' ';
        int i = 0;
        int cnt = atoi(buff); //converts string to int.. buff == # of chars in file?
        arr[line_number-1].count[counter] = cnt; //at this point line_number == 1
        printf("fire1\n");

        while(c!='\0')
        {
            c=buff[i];
            buff[i]=buff[i+6];
            i++;
        }


        int cnnt = 0;
        while(c!=' ')
        {
            c = buff[cnnt];
            cnnt++;
        }
        i=0;
        while(c!='\0')
        {
            c=buff[i];
            buff[i]=buff[i+cnnt];
            i++;
        }
        sprintf(arr[line_number-1].wordlist[counter],"%s",buff);
        printf("%d %s",arr[line_number-1].count[counter],arr[line_number-1].wordlist[counter]);
        counter++;
    }
    printf("final count: %d", counter);
    arr[line_number-1].count[counter] = -1;


    fclose(in);



    //pthread_exit(NULL); //didn't help to move here from getCurrentSegment...()
    return NULL;
}



void *getCurrentSegmentWordcount(void * tid) { //declaring file pointer (value?)
    int segment = tid;
    segment = segment + 1; //converts to int
    printf("segment/thread: %d \n", segment);
    char text[1000];
    //char buffer[150];
    FILE *fp = fopen("words.txt", "r");
    if(fp == NULL) {
        printf("null file");
    }
    int i = 0;

    long lSize;
    char *buffer;
    if( !fp ) perror("words.txt"),exit(1);

    fseek( fp , 0L , SEEK_END);
    lSize = ftell( fp );
    rewind( fp );

    buffer = calloc( 1, lSize+1 );
    if( !buffer ) fclose(fp),fputs("memory alloc fails",stderr),exit(1);

    if( 1!=fread( buffer , lSize, 1 , fp) )
      fclose(fp),free(buffer),fputs("entire read fails",stderr),exit(1);

    //printf(buffer);

    char *token = strtok(buffer, "~");

    if(segment == 1) {
        printf("segment 1: %s", token);
        word_count(&segment);
    }

    if(segment == 2) {
        token = strtok(NULL,"~");
        printf("segment 2: %s", token);
    }

    if(segment == 3) {
        token = strtok(NULL,"~");
        token = strtok(NULL,"~");
        printf("segment 3: %s", token);
    }

    if(segment == 4) {
        token = strtok(NULL,"~");
        token = strtok(NULL,"~");
        token = strtok(NULL,"~");
        printf("segment 4: %s", token);
    }

    fclose(fp);
    free(buffer);
    //pthread_exit(NULL);//moving to end of word_count()
}

int main(int argc, char *argv[])
{
    //The main program creates x threads and then exits.
    pthread_t threads[NUMBER_OF_THREADS];
    int status, i;

    for(i=0; i < NUMBER_OF_THREADS; i++) {
        printf("Main here. Creating thread %d\n", i+1);
        status = pthread_create(&threads[i], NULL, getCurrentSegmentWordcount, (void * )i);
        if (status != 0) {
            printf("Oops. pthread create returned error code %d\n", status);
            exit(-1);
        }
    }
    sleep(8);
    exit(NULL);
}

Output:

Main here. Creating thread 1
Main here. Creating thread 2
segment/thread: 1 
Main here. Creating thread 3
segment 1: test(segment 1, handled my thread 1)
Thread 1
Main here. Creating thread 4
Command: sed -n '1p' 'maintainers.txt' | tr [:space:] '\n' | grep -v '^\s*$' | sort | uniq -c | sort
Main here. Creating thread 5
segment/thread: 2 
before
segment/thread: 4 
Main here. Creating thread 6
segment 4: 
test test test test (segment 4, handled by thread 4)
Main here. Creating thread 7
segment 2: 
test test (segment 2, handled by thread 2)
Main here. Creating thread 8
Main here. Creating thread 9
Main here. Creating thread 10
segment/thread: 3 
segment 3: 
test test test (segment 3, handled by thread 3)
segment/thread: 10 
segment/thread: 9 
segment/thread: 8 
segment/thread: 5 
segment/thread: 6 
segment/thread: 7 
testBool: 1
Makefile:20: recipe for target 'all' failed
make: *** [all] Segmentation fault (core dumped)

Answer 1

There are many issues with this code, some have been already mentioned by user3629249 , so I'll try to summarize the errors here.

Passing (void * )i for the argument for the thread is rather ugly. Sure it works but this is for me sloppy programming, I'd declare an int array and fill it with the id values and pass a pointer to the locations.

int ids[NUMBER_OF_THREADS];

for(i=0; i < NUMBER_OF_THREADS; i++) {
    ids[i] = i+1;
    status = pthread_create(&threads[i], NULL, getCurrentSegmentWordcount, ids + i);
    ...
}

and then in the thread function:

void *getCurrentSegmentWordcount(void * tid) { //declaring file pointer (value?)
    int segment = *((int*) tid);
    // segment = segment + 1; not needed anymore
    ...
}

This code is more clean, easier to understand for you and for the code reviewer, does not relay on ugly unnecessary casts and is more portable.

Same thing with

void *print_hello_world(void *tid)
{
    //This function prints the thread’s identifier and then exits.
    printf("Hello World. Greetings from thread %d\n", tid);
    pthread_exit(NULL);
}

This is uggly, you are trying to pass a pointer as an int . The size of a pointer may not be the same as the size of an int . Using the same way of passing a pointer to int (like for getCurrentSegmentWordcount ):

void *print_hello_world(void *tid)
{
    //This function prints the thread’s identifier and then exits.
    printf("Hello World. Greetings from thread %d\n", *((int*) tid));
    pthread_exit(NULL);
}

---

Write error messages to stderr . This FILE buffer is opened for that reason, that's what people expect from programs to do. When you execute a program, you can do this:

$ program 2>/tmp/error.log

or this

$ program 2>/dev/null | some_other_tool

so that you can separate the normal output from the error outputs.

And when a system function fails, the errno variable is set to the error code. You can use perror for a standard error message or if you want a custom one, use strerror :

pid_t p = fork();

if(p < 0)
{
    perror("fork failed");
    // or
    fprintf(stderr, "Error while executing fork: %s\n", strerror(errno));
    return; // or exit or whatever
}

---

You can write code in one line if you want to enter the C obfuscated contest, otherwise don't do that. It's hard to read for you, it's hard to read for the code reviewer/co-worker/superior. You gain nothing from it.

Instead of

if( !buffer ) fclose(fp),fputs("memory alloc fails",stderr),exit(1);

do

if(buffer == NULL)
{
    fclose(fp);
    fputs("memory alloc fails", stderr);
    exit(EXIT_FAILURE); // or exit(your_exit_status)
}

It's easier to read for everyone.

---

You should always check the return value of functions that return a pointer. Check the return value of malloc , calloc , realloc , strtok , etc.

if(segment == 2) {
    token = strtok(NULL,"~");
    printf("segment 2: %s", token);
}

If strtok returns NULL , then the printf line yields undefined behaviour. See 3.5.3.3 comment 2 :

3.5.3.3 :

Synopsis

  #define __STDC_WANT_LIB_EXT1__ 1 #include <stdio.h> int printf_s(const char * restrict format, ...); 

[...]

² format shall not be a null pointer. The %n specifier (modified or not by flags, field width, or precision) shall not appear in the string pointed to by format. Any argument to printf_s corresponding to a %s specifier shall not be a null pointer .

[...]

⁴ The printf_s function is equivalent to the printf function except for the explicit runtime-constraints listed above.

Some libc implementation may forgive you to pass NULL to printf with %s and print (null) , but this is not portable and is undefined behaviour. So you can only do the printf if token is not NULL .

---

The word_count function is a little bit horrible, specially how you construct the commands.

char cmd_p1[9] = "sed -n '\0";

can be rewritten as

char cmd_p1[] = "sed -n '";

This will create a char array with the correct amount of bytes and initialize it with a valid 0-terminated string, no need to add the ' \\0 ' yourself.

The commands that are the same, meaning that they don't need a value from a variable can be store in a char[] or even in a const char* . Then construct the whole thing with snprintf and sprintf , less lines, less mistakes:

void *word_count(void* num)
{
    ...
    const char *pipe_cmd = "| tr [:space:] '\\n' | grep -v '^\\s*$' | sort | uniq -c | sort";
    const char *format = "sed -n '%dp' 'maintainers.txt' %s";

    int cmd_size = snprintf(NULL, 0, format, line_number, pipe_cmd);

    char *command = malloc(cmd_size + 1);
    if(command == NULL)
        return NULL;

    sprintf(command, format, line_number, pipe_cmd);

    ...

    FILE *in;
    in= popen(command, "r");
    free(command);
    ...
}

Also note that

char cmd_p2[2];
sprintf(cmd_p2,"%d",line_number); //stores string in buffer

will overflow the buffer if the line number is greater than 9.

---

bool testBool = fgets(buff,sizeof(buff),in);
printf("testBool: %d\n", testBool);

fgets returns a pointer to char , not a bool . The printf will print the value of a pointer as an integer. A pointer size is not necessarily the same as an int size, in fact on my system a pointer is 8 bytes long, int is 4 bytes long. You should do:

if(fgets(buff, sizeof(buff), in))
    puts("fgets success");

---

//CRASH HAPPENS HERE:
//buff 
printf("sizeof Buff: %d", sizeof(buff));

1. It won't crash because of the sizeof . sizeof is evaluated at compile time, not at run-time.
2. The sizeof -operator returns a size_t .

3. %d is not the correct specifier for size_t , %lu is, it should be

    printf("sizeof buff: %lu\\n", sizeof buff); 

4. It will most probably crash because of all the undefined behaviour before this point.

---

arr[line_number-1].count[counter] = cnt;

In your whole code, arr is uninitialized, so you are accessing a value through an uninitialized pointer. That's undefined behaviour and might lead to a segfault.

---

I want to quote user3629249 here:

user3629249 wrote :

the main() function is starting several threads, then immediately exiting. The process of exiting also eliminates the threads Suggest: in main() calling pthread_join() for each thread. in the thread, at the end, call pthread_exit()

---

Please don't ignore compiler warnings, they are not there to annoy you, they are there to help you. They are a hint that what you are doing may not be what you really want. Undefined behaviour, segfaults etc. are often a consequence of that. So heed warnings of the compiler and when you see one, look at your code, try to understand it and fix it. If you don't understand the warning, you can come here and ask a question about it. But having thousand of warning and ignoring them will lead to headaches and quite franky a lot of wasted time on your side and ours.

So, please fix all this warnings and details, look at the warning messages of the compiler and the code might run without problems.