C程序守护程序使用100％的CPU使用率

Question

I'm initializing a daemon in C in a Debian:

/**
 * Initializes the daemon so that mcu.serial would listen in the background
 */
void init_daemon()
{
    pid_t process_id = 0;
    pid_t sid = 0;

    // Create child process
    process_id = fork();

    // Indication of fork() failure
    if (process_id < 0) {
        printf("Fork failed!\n");
        logger("Fork failed", LOG_LEVEL_ERROR);
        exit(1);
    }

    // PARENT PROCESS. Need to kill it.
    if (process_id > 0) {
        printf("process_id of child process %i\n", process_id);
        exit(0);
    }

    //unmask the file mode
    umask(0);
    //set new session
    sid = setsid();

    if(sid < 0) {
        printf("could not set new session");
        logger("could not set new session", LOG_LEVEL_ERROR);
        exit(1);
    }

    // Close stdin. stdout and stderr
    close(STDIN_FILENO);
    close(STDOUT_FILENO);
    close(STDERR_FILENO);
}

The main daemon runs in the background and monitors a serial port to communicate with a microcontroller - it reads peripherals (such as button presses) and passes information to it. The main functional loop is

int main(int argc, char *argv[])
{
    // We need the port to listen to commands writing
    if (argc < 2) {
        fprintf(stderr,"ERROR, no port provided\n");
        logger("ERROR, no port provided", LOG_LEVEL_ERROR);
        exit(1);
    }
    int portno = atoi(argv[1]);

    // Initialize serial port
    init_serial();

    // Initialize server for listening to socket
    init_server(portno);

    // Initialize daemon and run the process in the background
    init_daemon();

    // Timeout for reading socket
    fd_set setSerial, setSocket;
    struct timeval timeout;
    timeout.tv_sec = 0;
    timeout.tv_usec = 10000;

    char bufferWrite[BUFFER_WRITE_SIZE];
    char bufferRead[BUFFER_READ_SIZE];
    int n;
    int sleep;
    int newsockfd;
    while (1)
    {
        // Reset parameters
        bzero(bufferWrite, BUFFER_WRITE_SIZE);
        bzero(bufferRead, BUFFER_WRITE_SIZE);
        FD_ZERO(&setSerial);
        FD_SET(fserial, &setSerial);
        FD_ZERO(&setSocket);
        FD_SET(sockfd, &setSocket);

        // Start listening to socket for commands
        listen(sockfd,5);
        clilen = sizeof(cli_addr);
        // Wait for command but timeout
        n = select(sockfd + 1, &setSocket, NULL, NULL, &timeout);
        if (n == -1) {
            // Error. Handled below
        } 

        // This is for READING button 
        else if (n == 0) {
            // This timeout is okay 
            // This allows us to read the button press as well

            // Now read the response, but timeout if nothing returned
            n = select(fserial + 1, &setSerial, NULL, NULL, &timeout);
            if (n == -1) {
                // Error. Handled below
            } else if (n == 0) {
                // timeout
                // This is an okay tiemout; i.e. nothing has happened
            } else {
                n = read(fserial, bufferRead, sizeof bufferRead);
                if (n > 0) {
                    logger(bufferRead, LOG_LEVEL_INFO);
                    if (strcmp(stripNewLine(bufferRead), "ev b2") == 0) {
                        //logger("Shutting down now", LOG_LEVEL_INFO);
                        system("shutdown -h now");
                    }
                } else {
                    logger("Could not read button press", LOG_LEVEL_WARN);
                }
            }
        } 

        // This is for WRITING COMMANDS
        else {
            // Now read the command
            newsockfd = accept(sockfd, (struct sockaddr *) &cli_addr, &clilen);

            if (newsockfd < 0 || n < 0) logger("Could not accept socket port", LOG_LEVEL_ERROR);

            // Now read the command
            n = read(newsockfd, bufferWrite, BUFFER_WRITE_SIZE);
            if (n < 0) {
                logger("Could not read command from socket port", LOG_LEVEL_ERROR);
            } else {
                //logger(bufferWrite, LOG_LEVEL_INFO);
            }

            // Write the command to the serial
            write(fserial, bufferWrite, strlen(bufferWrite));
            sleep = 200 * strlen(bufferWrite) - timeout.tv_usec;  // Sleep 200uS/byte
            if (sleep > 0) usleep(sleep);

            // Now read the response, but timeout if nothing returned
            n = select(fserial + 1, &setSerial, NULL, NULL, &timeout);
            if (n == -1) {
                // Error. Handled below
            } else if (n == 0) {
                // timeout
                sprintf(bufferRead, "err\r\n");
                logger("Did not receive response from MCU", LOG_LEVEL_WARN);
            } else {
                n = read(fserial, bufferRead, sizeof bufferRead);
            }
            // Error reading from the socket
            if (n < 0) {
                logger("Could not read response from serial port", LOG_LEVEL_ERROR);
            } else {
                //logger(bufferRead, LOG_LEVEL_INFO);
            }

            // Send MCU response to client
            n = write(newsockfd, bufferRead, strlen(bufferRead));
            if (n < 0) logger("Could not write confirmation to socket port", LOG_LEVEL_ERROR);
        }

        close(newsockfd);
    }

    close(sockfd);
    return 0;
}

But the CPU usages is always at 100%. Why is that? What can I do?

EDIT

I commented out the entire while loop and made the main function as simple as:

int main(int argc, char *argv[])
{
    init_daemon();
    while(1) {
        // All commented out
    }
    return 0;
}

And I'm still getting 100% cpu usage

Answer 1

You need to set timeout to the wanted value on every iteration, the struct gets modified on Linux so I think your loop is not pausing except for the first time, ie select() is only blocking the very first time.

Try to print tv_sec and tv_usec after select() and see, it's modified to reflect how much time was left before select() returned.

Move this part

timeout.tv_sec = 0;
timeout.tv_usec = 10000;

inside the loop before the select() call and it should work as you expect it to, you can move many delcarations inside the loop too, that would make your code easier to maintan, you could for example move the loop content to a function in the future and that might help.

This is from the linux manual page select(2)

On Linux, select() modifies timeout to reflect the amount of time not slept; most other implementations do not do this. (POSIX.1-2001 permits either behavior.) This causes problems both when Linux code which reads timeout is ported to other operating systems, and when code is ported to Linux that reuses a struct timeval for multiple select() s in a loop without reinitializing it . Consider timeout to be undefined after select() returns.

I think the bold part in the qoute is the important one.